From 68fc8e96a9629e73469ed457abd955e548ec670c Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:49:58 +0100 Subject: unslug pt-br: move --- .../index.html" | 21 + files/pt-br/orphaned/hello_world_rust/index.html | 191 +++++++ files/pt-br/orphaned/instalando_rust/index.html | 132 +++++ .../orphaned/learn/how_to_contribute/index.html | 90 ++++ .../learn/html/forms/html5_updates/index.html | 112 ++++ files/pt-br/orphaned/mdn/community/index.html | 42 ++ .../mdn/community/whats_happening/index.html | 37 ++ .../mdn/community/working_in_community/index.html | 100 ++++ .../howto/create_an_mdn_account/index.html | 43 ++ .../howto/do_a_technical_review/index.html | 52 ++ .../howto/do_an_editorial_review/index.html | 55 ++ .../howto/set_the_summary_for_a_page/index.html | 61 +++ .../howto/tag_javascript_pages/index.html | 84 +++ .../index.html | 114 ++++ .../cross-team_collaboration_tactics/index.html | 65 +++ files/pt-br/orphaned/mdn/dashboards/index.html | 17 + files/pt-br/orphaned/mdn/editor/basics/index.html | 65 +++ files/pt-br/orphaned/mdn/editor/index.html | 10 + .../mdn/tools/page_regeneration/index.html | 32 ++ .../temporary_installation_in_firefox/index.html | 95 ++++ .../tools/add-ons/dom_inspector/index.html | 81 +++ files/pt-br/orphaned/tools/add-ons/index.html | 21 + files/pt-br/orphaned/tools/css_coverage/index.html | 136 +++++ .../disable_breakpoints/index.html | 19 + .../tools/debugger_(before_firefox_52)/index.html | 58 ++ .../jaws_issues_with_firefox/index.html | 11 + .../index.html" | 55 ++ .../index.html" | 20 + .../orphaned/web/html/element/command/index.html | 129 +++++ files/pt-br/orphaned/web/html/favicon/index.html | 32 ++ .../cole\303\247\303\265es_chaveadas/index.html" | 149 ++++++ .../javascript/guide/sintaxe_e_tipos/index.html | 583 +++++++++++++++++++++ .../global_objects/array/prototype/index.html | 206 ++++++++ .../global_objects/bigint/prototype/index.html | 61 +++ .../information_security_basics/index.html | 32 ++ 35 files changed, 3011 insertions(+) create mode 100644 "files/pt-br/orphaned/glossary/tratando_formul\303\241rios_com_php/index.html" create mode 100644 files/pt-br/orphaned/hello_world_rust/index.html create mode 100644 files/pt-br/orphaned/instalando_rust/index.html create mode 100644 files/pt-br/orphaned/learn/how_to_contribute/index.html create mode 100644 files/pt-br/orphaned/learn/html/forms/html5_updates/index.html create mode 100644 files/pt-br/orphaned/mdn/community/index.html create mode 100644 files/pt-br/orphaned/mdn/community/whats_happening/index.html create mode 100644 files/pt-br/orphaned/mdn/community/working_in_community/index.html create mode 100644 files/pt-br/orphaned/mdn/contribute/howto/create_an_mdn_account/index.html create mode 100644 files/pt-br/orphaned/mdn/contribute/howto/do_a_technical_review/index.html create mode 100644 files/pt-br/orphaned/mdn/contribute/howto/do_an_editorial_review/index.html create mode 100644 files/pt-br/orphaned/mdn/contribute/howto/set_the_summary_for_a_page/index.html create mode 100644 files/pt-br/orphaned/mdn/contribute/howto/tag_javascript_pages/index.html create mode 100644 files/pt-br/orphaned/mdn/contribute/howto/write_an_article_to_help_learn_about_the_web/index.html create mode 100644 files/pt-br/orphaned/mdn/contribute/processes/cross-team_collaboration_tactics/index.html create mode 100644 files/pt-br/orphaned/mdn/dashboards/index.html create mode 100644 files/pt-br/orphaned/mdn/editor/basics/index.html create mode 100644 files/pt-br/orphaned/mdn/editor/index.html create mode 100644 files/pt-br/orphaned/mdn/tools/page_regeneration/index.html create mode 100644 files/pt-br/orphaned/mozilla/add-ons/webextensions/temporary_installation_in_firefox/index.html create mode 100644 files/pt-br/orphaned/tools/add-ons/dom_inspector/index.html create mode 100644 files/pt-br/orphaned/tools/add-ons/index.html create mode 100644 files/pt-br/orphaned/tools/css_coverage/index.html create mode 100644 files/pt-br/orphaned/tools/debugger_(before_firefox_52)/disable_breakpoints/index.html create mode 100644 files/pt-br/orphaned/tools/debugger_(before_firefox_52)/index.html create mode 100644 files/pt-br/orphaned/web/accessibility/jaws_issues_with_firefox/index.html create mode 100644 "files/pt-br/orphaned/web/api/node/entendendo_o_uso_do_m\303\251todo_appendchild-javascript/index.html" create mode 100644 "files/pt-br/orphaned/web/guide/css/css_media_queries_(consultas_de_m\303\255dia_em_css)/index.html" create mode 100644 files/pt-br/orphaned/web/html/element/command/index.html create mode 100644 files/pt-br/orphaned/web/html/favicon/index.html create mode 100644 "files/pt-br/orphaned/web/javascript/guide/cole\303\247\303\265es_chaveadas/index.html" create mode 100644 files/pt-br/orphaned/web/javascript/guide/sintaxe_e_tipos/index.html create mode 100644 files/pt-br/orphaned/web/javascript/reference/global_objects/array/prototype/index.html create mode 100644 files/pt-br/orphaned/web/javascript/reference/global_objects/bigint/prototype/index.html create mode 100644 files/pt-br/orphaned/web/security/information_security_basics/index.html (limited to 'files/pt-br/orphaned') diff --git "a/files/pt-br/orphaned/glossary/tratando_formul\303\241rios_com_php/index.html" "b/files/pt-br/orphaned/glossary/tratando_formul\303\241rios_com_php/index.html" new file mode 100644 index 0000000000..db1791d5e7 --- /dev/null +++ "b/files/pt-br/orphaned/glossary/tratando_formul\303\241rios_com_php/index.html" @@ -0,0 +1,21 @@ +--- +title: Tratando Formulários com PHP +slug: Glossario/Tratando_Formulários_com_PHP +tags: + - Método POST + - PHP +translation_of: Glossary/Tratando_Formulários_com_PHP +--- +

Uma das características mais fortes do PHP é o jeito como ele trata formulários HTML. O conceito básico que é importante entender é que qualquer elemento de formulário irá automaticamente ficar disponível para seus scripts PHP. Por favor leia a seção Variáveis externas do PHP para mais informações e exemplos de como usar formulários com PHP. Aqui vai um exemplo de formulário HTML:

+ +

Enviando Dados com método POST

+ +

 

+ +
<form action="arquivo.php" method="post">
+ <p>Nome: <input type="text" name="nnome" /></p>
+ <p>idade: <input type="text" name="idade" /></p>
+ <p><input type="submit" /></p>
+</form>
+ +

 

diff --git a/files/pt-br/orphaned/hello_world_rust/index.html b/files/pt-br/orphaned/hello_world_rust/index.html new file mode 100644 index 0000000000..f472f6a3e9 --- /dev/null +++ b/files/pt-br/orphaned/hello_world_rust/index.html @@ -0,0 +1,191 @@ +--- +title: Hello World Rust +slug: Hello_World_Rust +tags: + - Performance + - baixo-nível + - brazil + - compilada + - compile + - hello world + - low-level + - programar + - programming + - pt-br + - rust + - rustontherocks + - servo +--- +

Hello, World!

+ +

 

+ +

 

+ +

Que tal  escrevermos um clássico programa em Rust?

+ +

 

+ +

Uma coisa legal sobre começar com programas simples é o fato de que você percebe que o seu compilador não está somente instalado como também está funcionando propriamente.

+ +

 

+ +

A primeira coisa que nós precisamos fazer é criar um local para que possamos organizar nossos códigos. Eu gosto de criar uma pasta projetos dentro da minha pasta home. Lembrando que o Rust não se importa com o local onde o seu código se encontra.

+ +

 

+ +

Isso nos leva a uma outro detalhe: eu estou  assumindo que você já tem uma certa familiaridade com a linha de comando. Se você preferir utilizar uma IDE ao invés da linha de comando, você talvez queira dar uma olhada no SolidOak(https://github.com/oakes/SolidOak ), ou qualquer plugin disponível para a sua IDE preferida. Existem por aí um bom número de extensões com qualidade variável em desenvolvimento por parte da comunidade. A equipe Rust também desenvolve plugins para vários editores(https://github.com/rust-lang/rust/blob/master/src/etc/CONFIGS.md ).

+ +

 

+ +

Dito isso, vamos criar um deretório dentro da nossa pasta projetos.

+ +

 

+ +

$ mkdir ~/projects

+ +

$ cd ~/projects

+ +

$ mkdir hello_world

+ +

$ cd hello_world

+ +

 

+ +

Caso você esteja no Windows e não esteja utilizando PowerShell, talvez o ~ não funcione. Consulte a documentação do seu shell para mais detalhes.

+ +

 

+ +

Vamos criar um arquivo para o nosso código. Nós chamamos nosso arquivo de main.rs. Arquivos Rust são sempre terminados com a extensão .rs. Caso você esteja utilizando mais de uma palavra no nome de seu arquivo, é preferível que você utilize o underscore/underline: hello_world.rs ao invés de concatenar tudo como: helloword.rs. No mundo rust isso é chamado de snake_case.

+ +

 

+ +

Agora que você já tem o seu arquivo abra-o e digite o seguinte código:

+ +

 

+ +

fn main() {

+ +

println!("Hello, world!");

+ +

}

+ +

 

+ +

Salve o arquivo e digite o seguinte no seu terminal:

+ +

 

+ +

$ rustc main.rs

+ +

$ ./main # ou main.exe no Windows

+ +

Hello, world!

+ +

 

+ +

Sucesso!

+ +

 

+ +

Agora, como diria Jack: "Vamos por partes...".

+ +

 

+ +

fn main() {

+ +

 

+ +

}

+ +

 

+ +

Estas linhas definem uma função em Rust. A função main é de fato especial: ela é o começo de todo programa feito em Rust. Essas primeiras linhas dizem “Eu estou declarando uma função chamada main que não possui nenhum argumento e não retorna valor nenhum.” Caso tivesse argumentos eles estariam dentro dos parênteses (( )), e como não estamos retornando nada nós podemos omitir o tipo de retorno inteiramente. Falaremos mais sobre isso em tutoriais futuros.

+ +

 

+ +

Você também deve notar que a função é envolta por chaves ({ }). Rust exige chaves em volta do escopo das funções. Também é considerado uma boa prática abrir chaves na mesma linha onde foi declarada a função.

+ +

 

+ +

Próxima linha:

+ +

 

+ +

println!("Hello, world!");

+ +

 

+ +

Esta linha faz todo o trabalho do nosso pequeno programa. Existem inúmeros detalhes importantes nela. Lembre-se de configurar o seu editor para que utilize quatro espaços para fazer a identação. É disponibilizado várias configurações para alguns editores (https://github.com/rust-lang/rust/blob/master/src/etc/CONFIGS.md).

+ +

 

+ +

O segundo ponto é a parte do println!( ).

+ +

Este trecho de código chama uma macro(http://doc.rust-lang.org/book/macros.html) Rust, que é a forma como Rust realiza a metaprogramação. Se ao invés de uma macro fosse uma função, teríamos algo como: println( ). Para o nosso propósito aqui, nós não precisamos nos preocupar com essa diferença. Apenas saiba que algumas vezes você irá ver ' ! ', o que indica uma chamada de macro e não uma chamada de função normal. Rust implementa println!( ) como uma macro e não como uma simples função por alguns bons motivos, contudo, como dito, não se faz necessário explicar agora.

+ +

Uma última ressalva:se você já usou macros em outras linguagens como C/C++, você verá que as macros do Rust são bastante diferentes. Não fique assustado com as macros. Nós vamos entendendo melhor ao longo dos próximos tutoriais.

+ +

 

+ +

Próximo, "Hello, world!" é uma 'string'. Strings são geralmente bastante complicadas em uma 'system language', e ainda mais, temos uma string estáticamente alocada. Caso você queira ler mais sobre alocação, confira este link: http://doc.rust-lang.org/book/the-stack-and-the-heap.html, mas por hora não se faz necessário.

+ +

Voltando, nós passamos a nossa string como um argumento para a macro println!, que por sua vez imprime na tela a nossa 'string'. Fácil!

+ +

 

+ +

Finalmente, a nossa linha de código termina com um ponto e vírgula ( ; ). Rust é uma linguagem orientada à expressões, o que significa que a maior parte da linguagem são expressões e não apenas declarações. O ; é usado para indicar que uma expressão terminou e que a próxima está prestes a começar. A grande maioria das linhas de código em Rust acabarão com ;.

+ +

 

+ +

Por fim, compilar e executar.

+ +

Para compilar usamos o nosso compilador rustc e em seguida passamos o nome do nosso arquivo:

+ +

 

+ +

$ rustc main.rs

+ +

 

+ +

Caso você tenha experiência com C/C++ verá que existe semelhança com o gcc e clang. Após o comando, Rust gerará um binário executável. Podemos vê-lo utilizando o comando ls:

+ +

 

+ +

$ ls

+ +

mainmain.rs

+ +

 

+ +

No Windows:

+ +

$ dir

+ +

main.exemain.rs

+ +

 

+ +

Agora temos dois arquivos, o nosso código com a extensão .rs e o executável(main.exe para Windows ou main para os demais).

+ +

 

+ +

$ ./main # or main.exe on Windows

+ +

 

+ +

O comando acima exibe a nossa string hello, world! no terminal.

+ +

 

+ +

Caso você venha de alguma linguagem dinâmica como Ruby, Python ou Javascript épossível que você nunca tenha feito esses dois passos anteriores em separado. Rust é uma linguagem “anteriormente compilada”, o que significa que você pode compilar um programa e compartilhar com alguém que não tenha Rust instalado e essa pessoa irá conseguir executar numa boa. Agora, se você compartilhar um arquivo .rb ou .py ou .js a pessoa com quem você compartilhou precisará ter Ruby/Python/Javascript instalado, em contra-partida com estas linguagens você compila e roda em um único comando. Tudo é uma questão de escolha quando se trata de padrões de linguagem e Rust fez as dele.

+ +

 

+ +

Parabéns! Você oficialmente escreveu seu primeiro programa em Rust. Isso lhe torna um programador Rust! Bem-vindo!!!

+ +

 

+ +

 

+ +

 

diff --git a/files/pt-br/orphaned/instalando_rust/index.html b/files/pt-br/orphaned/instalando_rust/index.html new file mode 100644 index 0000000000..883144991d --- /dev/null +++ b/files/pt-br/orphaned/instalando_rust/index.html @@ -0,0 +1,132 @@ +--- +title: Instalando Rust +slug: Instalando_Rust +tags: + - Linux + - Tutorial + - Windows + - baixo nivel + - brasil + - brazil + - hello world + - install + - low-level + - programming + - rust + - rustontherocks + - system language +--- +

Instalando o Rust

+ +

 

+ +

O primeiro passo é instalar. Existem várias maneiras de se instalar o Rust, porém a maneiras mais fácil é através do script 'rustup'. Se o seu sistema é Gnu/Linux ou Mac, eis o que você precisa fazer:

+ +

 

+ +
+

$ curl -sf -L https://static.rust-lang.org/rustup.sh | sh

+
+ +

 

+ +

Se você está preocupado com a potencial brecha de segurança de usar curl | sh , por favor continue lendo e veja a nossa alternativa abaixo. Sinta-se à vontade para fazer o processo em dois passos:

+ +

 

+ +
+

$ curl -f -L https://static.rust-lang.org/rustup.sh -O

+ +

$ sh rustup.sh

+
+ +

 

+ +
+

Se você utiliza Windows, por favor baixe o instalador correto para a sua máquina:

+ +

 

+ +

32bits https://static.rust-lang.org/dist/rust-1.0.0-beta-i686-pc-windows-gnu.msi

+ +

 

+ +

64bits https://static.rust-lang.org/dist/rust-1.0.0-beta-x86_64-pc-windows-gnu.msi

+
+ +

Ah, antes que eu esqueça!

+ +

 

+ +

Plataformas oficialmente suportadas:

+ +

 

+ +
+

      Windows (7, 8, Server 2008 R2)

+ +

Gnu/Linux(2.6.18 ou posterior, várias distribuições), x86 e x86-64

+ +

OSX 10.7(Lion) ou posterior, x86 e x86-64

+
+ +
+
+ +

Rust foi bastante testado nestas plataformas e em algumas outras, como android. Mas estas são as mais amigáveis para se trabalhar, uma vez que foram as mais testadas.

+ +

 

+ +

Finalmente, um comentário sobre Windows. Rust considerou Windows como uma plataforma de primeira classe na fase de lançamento. Contudo, se formos honestos precisamos dizer que a experiência no Windows não é tão boa quanto no Gnu/Linux e OS X. Estamos trabalhando para melhorar isso! Se alguma coisa não funcionar, é um 'bug'. Por favor avise-nos caso isso venha a acontecer. Cada 'commit' é testado no Windows assim como em qualquer outra plataforma.

+ +

 

+ +

Se você tem Rust instalado, você pode abrir um terminal e digitar o seguinte:

+ +

 

+ +
+

$ rustc –version

+
+ +

 

+ +

Você deverá ver como saída o número da versão do Rust que está instalada, o 'commit hash', a data do 'commit' e a data que foi compilado.

+ +

 

+ +
+

rustc 1.0.0-beta (9854143cb 2015-04-02) (built 2015-04-02)

+
+ +

 

+ +

Caso você veja uma saída parecida com essa, parabéns Rust foi instalado com sucesso!

+ +

 

+ +
+

O instalador oficial também instala uma cópia da documentação para que você possa lê-la offline. Em sistemas UNIX, /usr/local/share/doc/rust é o local onde ela se encontra. No windows a documentação encontra-se na pasta share/doc dentro do local onde o Rust foi instalado.

+ +

 

+
+ +

Caso você não tenha obtido uma saída como a saida mostrada aqui, existem inúmeros lugares que você poderá pedir ajuda. O mais indicado é o canal do Rust no IRC (#rust) no servidor da mozilla (irc.mozilla.org). Você poderá acessar diretamente clicando neste link: https://client02.chat.mibbit.com/server=irc.mozilla.org&channel=%23rust .

+ +

 

+ +
+

Outro importantes links...

+ +

 

+ +

fórum dos usuários https://users.rust-lang.org/

+ +

RoR Project http://rustontherocks.org

+ +

Stack Overflow http://stackoverflow.com/questions/tagged/rust

+ +

 

+ +

 

+
diff --git a/files/pt-br/orphaned/learn/how_to_contribute/index.html b/files/pt-br/orphaned/learn/how_to_contribute/index.html new file mode 100644 index 0000000000..8b9cdfb15b --- /dev/null +++ b/files/pt-br/orphaned/learn/how_to_contribute/index.html @@ -0,0 +1,90 @@ +--- +title: Como contribuir para a área de aprendizagem da MDN +slug: Aprender/Como_contribuir +tags: + - Documentação + - Guia(2) + - Iniciante + - MDN Meta + - aprendizado + - contribuir + - prioridde + - pt-br +translation_of: Learn/How_to_contribute +--- +

Se você está aqui pela primeira vez ou após uma pesquisa mais aprofundada, é porque provavelmente você está interessado em contribuir para a área de aprendizado da MDN. Isto é uma excelente notícia!

+ +

Nesta página, você irá encontrar tudo o que você precisa para começar a ajudar a melhorar o conteúdo de aprendizado da MDN. Existem muitas coisas que você pode fazer, dependendo de quanto tempo você tem disponível ou se você éum iniciante, um desenvolvedor web, ou um professor.

+ +
+

Nota: se você já é um contribuinte do MDN, não hesite em checar novamente a pagina com o status da documentação para acompanhar o trabalho que tem sido feito e ver quais prioridades estão sendo escritas.

+
+ +
+

Nota: Os contribuintes estão utilizando um painel na Trello para organizar as suas tarefas. Se você quiser utilizar esta ferramenta, apena se registre na Trello e procure por Jeremie lhe dar acesso de escrita ao painel.

+
+ +

Encontre tarefas específicas

+ +

Uma forma comum que as pessoas usam para contribuir para a Área de aprendizado é lendo os artigos, corrigindo erros de digitação e sugerindo melhorias. Adição de exemplos no nosso repositório do github também é bem vindo e entre em contato conosco se você quiser pedir o que mais precisar.

+ +

Contribuir é um ótimo modo de se divertir enquanto aprende novas coisas. Se você se sentir perdido ou tiver dúvidas, não hesite em chegar até nós no "Fórum de conversa e aprendizado" ou no canal IRC (Veja o final da página para mais detalhes). Chris Mills é o "topic driver" da Área de aprendizado - você também poderia tentar contatá-lo diretamente.

+ +

As sessões a seguir oferecem algumas ideias gerais de tipos de tarefas que você pode fazer.

+ +

Eu sou um iniciante

+ +

Isto é incrível!  Iniciantes são muito importantes e valiosos para criar e dar feedback sobre o material de aprendizado. Você possui uma perspectiva única destes artigos já que você faz parte do público alvo, o que pode torna-lo um membro valioso da nossa equipe. De fato, se você está utilizando um dos nossos artigos para aprender algo e você ficar preso, ou de alguma forma achar o artigo confuso, você pode consertar isso ou nos contar sobre o problema para nós nos certificarmos que isso será corrigido.

+ +

Contribuir também é uma ótima maneira de se divertir enquanto aprende coisas novas se você se sentir perdido ou tiver perguntas, não hesite em nos contatar na nossa lista de e-mail ou no nosso canal IRC (obtenha detalhes na parte inferior desta página).

+ +

Aqui temos algumas sugestões de como você pode contribuir:

+ +
+
Adicionar tags para os nossos artigos (5 min)
+
Adicionar tags para o conteúdo do MDN é uma das maneiras mais fáceis de contribuir para a MDN. Uma de nossas diversas características é utilizar tags para ajudar no contexto da informação, é muito valioso contribuir com as tags. Para começar, dê uma olhada nesta lista de entradas do glosário e artigos de aprendizagem sem nenhuma tag.
+
Escrever e revisar entradas no glossário (15 min)
+
Como um iniciante, precisamos dos seus olhos ainda frescos olhando para o nosso conteúdo. Se você achar a entrada no glossário difícil de compreender, isto significa que está entrada precisa ser melhorada. Sinta-se livre para fazer qualquer mudança que você ache necessária. Se você acredita não ter a habilidade necessária para editar a entrada por você mesmo, nos comunique através da nossa lista de e-mail.
+
Escrever uma nova entrada no glossário (1 horas)
+
Esta é a maneira mais efetiva de aprender algo novo. Pegue um conceito sobre o qual você deseja aprender, e conforme você aprende sobre ele, escreva uma entrada no glossário. Explicar algo para os outros é uma ótima maneira de consolidar o conhecimento no seu cérebro, e ajudar para que as coisas possam fazer mais sentido para você, tudo enquanto ajuda outras pessoas. Todo mundo ganha!.
+
Ler e revisar um artigo de aprendizagem (2 horas)
+
É muito parecido com revisar entradas no glossário (veja acima); apenas leva mais tempo, geralmente estes artigos são um pouco maiores.
+
+ +

Eu sou um desenvolvedor web

+ +

Fantástico! Suas habilidades técnicas são tudo o que nós precisamos para certeza que fornecemos um conteúdo preciso para os iniciantes. Como esta parte específica do MDN é dedicada à aprendizagem da Web, certifique-se que as suas explicações são as mais simples possíveis, simples, porém úteis. É mais importante ser compreensível do que ser excessivamente precisa.

+ +
+
Escrever e revisar entradas no glossário (15 min)
+
Como um desenvolvedor web, nós precisamos de você tenha certeza que o nosso conteúdo é tecnicamente preciso, sem ser muito tedioso. Sinta-se livre para fazer qualquer mudança que você achar necessário. Se você quiser discutir o conteúdo antes da edição, nos contate na nossa lista de e-mail ou canal IRC.
+
Escrever uma nova entrada no glossário (1 hora)
+
Esclarecer termos técnicos é uma boa forma de aprender e ser ao mesmo tempo tecnicamente preciso e simples. Os iniciantes vão agradecer por isso. Nós temos muitos termos indefinidos que precisam da sua atenção. Pegue um e você já estará pronto para começar.
+
Escrever e revisar artigos de prendizagem (2 hora)
+
Esta é a mesma coisa que revisar uma entrada do glossário (ver acima); ela só leva um pouco mais de tempo pois estes artigos são um pouco maiores.
+
Escrever um novo artigo de aprendizagem (4 horas)
+
A MDN está em falta de alguns artigos simples sobre o uso de tecnologias web (HTML, CSS, JavaScript, etc). Temos também alguns conteúdos antigos na MDN que merecem ser revisados e reformulados. Leve as suas habilidades ao limite para tornar as tecnologias da Web utilizáveis mesmo para os iniciantes.
+
Criar exercícios, exemplos de código e ferramentas de aprendizagem interativas (? horas)
+
Todos os nossos artigos de aprendizagem exigem que chamamos de "aprendizagem ativa", porque as pessoas aprendem melhor fazendo algo por si mesmas. Tais materiais são exercícios ou conteúdos interativos que ajudam o usuário a aplicar e manipular os conceitos descritos em um artigo. Há muitas formas possíveis de tornar os conteúdos de aprendizagem interativos, desde a criação de amostras de código com JSFiddle, ou similar, liberte a sua criatividade para a construção de conteúdo interativo com Thimble.
+
+ +

Eu sou um professor

+ +

A MDN tem uma longa história de excelência técnica, mas falta profundidade de compreensão da melhor maneira de ensinar conceitos para os recém-chegados. E é aqui que precisamos de você, como um professor ou educador. Você pode nos ajudar a garantir que os nossos materiais possuam uma boa didática, e que sejam práticos para os nossos leitores.

+ +
+
Ler e revisar uma entrada no glossário (15 min)
+
Confira uma entrada de glossário e sinta-se livre para fazer qualquer alteração que você ache necessária. Se você quiser discutir sobre o conteúdo antes da edição, entre em contato conosco na nossa lista de e-mail ou canal IRC.
+
Escrever uma nova entrada no glossário  (1 hora)
+
Definições claras, simples de termos e conceitos básicos no glossário são fundamentais para atender às necessidades dos iniciantes. Sua experiência como educador pode ajudar a criar excelentes entradas de glossário; temos muitos termos indefinidos que precisam da sua atenção. Escolha um e vá a diante.
+
Adicionar ilustrações/ou esquemas para os artigos (1 hora)
+
Como você deve saber, as ilustrações são uma parte valiosa de qualquer conteúdo de aprendizagem. Isso é algo que muitas vezes não temos na MDN e suas habilidades podem fazer a diferença nessa área. Confira os artigos que necessitam conteúdo ilustrativo e pegue um que você queira criar gráficos.
+
Ler e revisar um artigo de aprendizagem (2 horas)
+
Isto é semelhante a revisar entradas de glossário (veja acima), mas exige mais tempo porque os artigos são um pouco maiores.
+
Escrever um novo artigo de aprendizagem (4 horas)
+
Precisamos de artigos simples e diretos sobre o ecossistema da Web e outros temas funcionais em torno deste tema. Uma vez que estes artigos de aprendizagem precisam ser educativos ao invés de tentar literalmente cobrir tudo que há para saber, sua experiência em saber o que cobrir será um grande trunfo.
+
Criar exercícios, questionários e ferramentas interativas de aprendizado (? horas)
+
Todos os nossos artigos de aprendizagem exigem "aprendizagem ativa". Tais materiais são exercícios ou conteúdo interativo que ajudam ao usuário aprender a usar e expandir os conceitos descritos em um artigo. Há muitas coisas que você pode fazer aqui, você pode ciar questionários para a construção de conteúdo interativo com o Thimble. Solte a sua criatividade!
+
Criar planos de aprendizagem (? horas)
+
A fim de fornecer tutoriais compreensíveis, precisamos moldar o nosso conteúdo em planos de aprendizagem. Esta é uma maneira de reunir o conteúdo existente e descobrir o que está faltando para criar um bom artigo de aprendizagem.
+
diff --git a/files/pt-br/orphaned/learn/html/forms/html5_updates/index.html b/files/pt-br/orphaned/learn/html/forms/html5_updates/index.html new file mode 100644 index 0000000000..7508276c28 --- /dev/null +++ b/files/pt-br/orphaned/learn/html/forms/html5_updates/index.html @@ -0,0 +1,112 @@ +--- +title: Formulários em HTML +slug: HTML/Forms_in_HTML +translation_of: Learn/HTML/Forms/HTML5_updates +--- +

{{ gecko_minversion_header("2") }}

+ +

Elementos e atributos de formulários em HTML5 proporcionam um grau de marcação semântica maior que HTML4 e remove grande parte da tediosa necessidade de se mexer com scripts e estilos que era necessária em HTML4. As características dos formulários em HTML5 proporcionam uma melhor experiência para usuários por tornarem formulários mais consistentes entre diferentes sites e dar um feedback imediato ao usuário sobre a entrada de dados. Eles também oferecem essa experiência para usuários que possuem scripts desabilitados em seus navegadores.

+ +

Este tópico descreve itens novos ou modificados que são suportados por Gecko/Firefox, versão 4 ou mais recente.

+ +

O elemento <input>

+ +

O elemento {{ HTMLElement("input") }} tem novos valores para o atributo {{ htmlattrxref("type", "input") }}.

+ + + +

O elemento {{ HTMLElement("input") }} também tem novos atributos:

+ + + +

O elemento <form>

+ +

O elemento {{ HTMLElement("form") }} possui um novo atributo:

+ + + +

O elemento <datalist>

+ +

O elemento {{ HTMLElement("datalist") }} representa a lista de elementos {{ HTMLElement("option") }} to suggest when filling an {{ HTMLElement("input") }} field.

+ +

Você pode usar o atributo {{ htmlattrxref("list", "input") }} em um elemento {{ HTMLElement("input") }} para ligar um específico campo de entrada com um específico elemento {{ HTMLElement("datalist") }}.

+ +

O elemento <output>

+ +

O elemento {{ HTMLElement("output") }} representa o resultado de um cálculo.

+ +

Você pode usar o atributo {{ htmlattrxref("for", "output") }} para especificar uma relação entre o elemento {{ HTMLElement("output") }} e outros elementos no documento que afetam o resultado do cálculo (por exemplo, como entradas ou parâmetros). O valor do atributo {{ htmlattrxref("for", "output") }} é uma lista de IDs separados por espaço de outros elementos.

+ +

{{ non-standard_inline() }} Gecko 2.0 (mas não necessariamente outras engines de navegador) suportasupports defining custom validity constraints e mensagens de erro de elementos {{ HTMLElement("output") }} , e portanto aplica as pseudo-classes CSS {{ Cssxref(":invalid") }}, {{ Cssxref(":valid") }}, {{ Cssxref(":-moz-ui-invalid") }}, e {{ Cssxref(":-moz-ui-valid") }} a eles. Isso pode ser útil em situações quando o resultado calculadoThis can be helpful in situations where the calculated result violates a business rule, but no specific input value does (for example, "The total of percentages must not exceed 100").

+ +

O atributo placeholder

+ +

O atributo {{ htmlattrxref("placeholder", "input") }} nos elementos {{ HTMLElement("input") }} e {{ HTMLElement("textarea") }} fornecem uma dica para o usuário do que pode ser inserido no campo. O texto do placeholder não pode conter caracteres de quebra de linha.

+ +

O atributo autofocus

+ +

O atributo {{ htmlattrxref("autofocus", "input") }} permite você especificar um campo de formulário que será focado automaticamente quando a página carregar. No documento, apenas um campo pode ter o atributo autofocus, que é um booleano. Este atributo pode ser aplicado aos seguintes elementos: {{ HTMLElement("input") }}, {{ HTMLElement("button") }}, {{ HTMLElement("select") }}, and {{ HTMLElement("textarea") }}. A única exceção é que o atributo autofocus não pode ser aplicado a um elemento {{ HTMLElement("input") }} caso  seu atributo {{ htmlattrxref("type", "input") }} seja hidden.

+ +

The label.control DOM property

+ +

The HTMLLabelElement DOM interface provides an extra property, in addition to the properties that correspond to the HTML {{ HTMLElement("label") }} element attributes. The control property returns the labeled control, that is, the control that the label is for, which is determined by the {{ htmlattrxref("for", "label") }} attribute (if it is defined) or by the first descendant control element.

+ +

Constraint Validation

+ +

HTML5 provides syntax and API items to support client-side validation of forms. While this functionality does not replace server-side validation, which is still necessary for security and data integrity, client-side validation can support a better user experience by giving the user immediate feedback about input data.

+ +

If the title attribute is set on the {{ HTMLElement("input") }} element, that string is displayed in a tooltip when validation fails. If the title is set to the empty string, no tooltip is displayed. If the title attribute isn't set, the standard validation message (as specified by the {{ htmlattrxref("x-moz-errormessage") }} attribute or by calling the setCustomValidity() method) is displayed instead.

+ +
Note: Constraint validation is not supported on {{ HTMLElement("button") }} elements in a form; to style a button based on the validity of the associated form, use the {{ cssxref(":-moz-submit-invalid") }} pseudo-class.
+ +

HTML Syntax for Constraint Validation

+ +

The following items in HTML5 syntax can be used to specify constraints on form data.

+ + + +

In addition, you can prevent constraint validation by specifying the {{ htmlattrxref("novalidate", "form") }} attribute on the {{ HTMLElement("form") }}, or the {{ htmlattrxref("formnovalidate", "button") }} attribute on the {{ HTMLElement("button") }} element and on the {{ HTMLElement("input") }} element (when {{ htmlattrxref("type", "input") }} is submit or image). These attributes indicate that the form is not to be validated when it is submitted.

+ +

Constraint Validation API

+ +

The following DOM properties and methods related to constraint validation are available to client-side scripts:

+ + + +

{{ languages({"es": "es/HTML/HTML5/Formularios_en_HTML5", "ja": "ja/HTML/HTML5/Forms_in_HTML5", "ko": "ko/HTML/HTML에서_폼"}) }}

+ +

{{ HTML5ArticleTOC() }}

diff --git a/files/pt-br/orphaned/mdn/community/index.html b/files/pt-br/orphaned/mdn/community/index.html new file mode 100644 index 0000000000..5157192748 --- /dev/null +++ b/files/pt-br/orphaned/mdn/community/index.html @@ -0,0 +1,42 @@ +--- +title: Participe da comunidade MDN +slug: MDN/Comunidade +tags: + - Comunidade + - Guia(2) + - Iniciando +translation_of: MDN/Community +--- +
{{MDNSidebar}}
+ +
+

A Documentação Web da MDN é mais que uma wiki: É uma comunidade de desenvolvedores trabalhando juntos para fazer do MDN um excelente material para desenvolvedores que usam as tecnologias abertas da Web.

+
+ +

Adoraríamos se você contribuísse com o MDN, mas adoraríamos ainda mais se participasse da comunidade MDN. Veja como se conectar, em três passos fáceis:

+ +
    +
  1. Crie uma conta no MDN.
    2. +
  2. Participe das conversas.
    3. +
  3. Siga o que está acontecendo.
    4. +
+ +

Como a comunidade funciona

+ +

A seguir, mais artigos que descrevem a comunidade MDN.

+ +
+
+
+
Cargos da comunidade
+
Existem vários cargos dentro da comunidade MDN com responsabilidades específicas.
+
Sprints de documentação
+
Este é um guia para organizar uma sprint de documentação. Ele contém recomendações e dicas de pessoas que já organizaram sprints de documentação, para te ajudar a organizar uma também.
+
Siga o que está acontecendo
+
A MDN chega até você através da comunidade da Rede de Desenvolvedores da Mozilla. Aqui estão algumas formas das quais nós compartilhamos informações sobre o que fazemos.
+
+ +
+
+
+
diff --git a/files/pt-br/orphaned/mdn/community/whats_happening/index.html b/files/pt-br/orphaned/mdn/community/whats_happening/index.html new file mode 100644 index 0000000000..93783e777f --- /dev/null +++ b/files/pt-br/orphaned/mdn/community/whats_happening/index.html @@ -0,0 +1,37 @@ +--- +title: Siga o que está acontecendo +slug: MDN/Comunidade/Whats_happening +translation_of: MDN/Community/Whats_happening +--- +
{{MDNSidebar}}

MDN is brought to you by Mozilla's Developer Engagement community. Here are some ways to that we share information about what we're doing.

+ +

Blogs

+ +
+
Mozilla Hacks
+
News about and in-depth coverage of Web and Mozilla technologies and features.
+
Engaging Developers
+
Promoting activity and discussion amongst the community involved in Developer Relations at Mozilla.
+
+ +

Streams of ephemera

+ + + +

Status boards and dashboards

+ +

The MDN documentation team maintains a Trello board on which our projects are tracked. This board is read-only but will let you see what's being worked on and what we hope to do soon, and may help you figure out where you can help.

+ +

In addtion, take a look at the Documentation status pages to see what's going on across the full breadth of MDN content. You'll be able to see what articles need to be written or updated, what topics need the most help, and much, much more.

+ +

MDN community meetings

+ +

Community meetings occur every two weeks on Wednesdays, 10:00 US Pacific time (UTC-0800 October-March, UTC-0700 in March-October), in the #mdn IRC channel. See the MDN community meetings wiki page for agendas and notes from past meetings.

+ +

The MDN Events calendar contains MDN community meetings, doc sprints, and other MDN-related events.

diff --git a/files/pt-br/orphaned/mdn/community/working_in_community/index.html b/files/pt-br/orphaned/mdn/community/working_in_community/index.html new file mode 100644 index 0000000000..38d851532d --- /dev/null +++ b/files/pt-br/orphaned/mdn/community/working_in_community/index.html @@ -0,0 +1,100 @@ +--- +title: Trabalhando em comunidade +slug: MDN/Comunidade/Trabalhando_em_comunidade +translation_of: MDN/Community/Working_in_community +--- +
{{MDNSidebar}}
+ +

Uma importante parte de contribuir com a documentação da MDN em qualquer escala significativa é saber como trabalhar como parte da comunidade MDN. Esse artigo oferece dicas sobre como você pode tirar o melhor proveito das suas interações com outros escritores e outros times de desenvolvimento.

+ +

Dicas gerais de etiqueta

+ +

Aqui estão algumas dicas gerais de conduta quando trabalhando na comunidade Mozilla.

+ + + +

Tenha sensatez

+ +

Sempre seja sensato e respeitoso quando se comunicar com os outros.

+ +

Gentilmente aponte os erros

+ +

Se seu propósito em contatar alguém é para pedi-los para fazer alguma coisa diferentemente, ou apontar enganos que eles estão cometendo (especialmente se eles repetidamente estão fazendo isto), inicie sua mensagem com um comentário positivo. Isto suaviza o impacto, por assim dizer, e demonstra que você está tentando ser prestativo, ao invés de definir você como o cara mau.

+ +

Por exemplo, se um novo contribuidor tiver criado muitos páginas sem tags, e você gostaria de pontuar esse problema, sua mensagem para eles podem ser desta forma (o que você precisa mudar para cada caso está sublinhado):

+ +
+

Oi, MrBigglesworth, eu tenho que notificar suas contribuições para a documentação da Wormhole API e isto é fantástico ter sua ajuda! Eu particularmente gosto do modo que você equilibra seu nível de detalhes com legibilidade. Dito isto, contudo, você poderia fazer estes artigos sempre melhores e mais pertinentes se adicionar as corretas tags para as páginas enquanto você elabora.

+ +

Veja o MDN guia de etiquetas (https://developer.mozilla.org/pt-BR/docs/MDN/Contribute/guia/Como-marcar-as-paginas-corretamente) para detalhes.

+ +

Obrigado novamente, e aguardo suas futuras contribuições!

+
+ +

Compartilhe conhecimento

+ +

Assim que você participa do projeto MDN, é útil saber o que está acontecendo, e interagir com outros membros de sua comunidade. Para conversar com outros em nossa comunidade, você pode seguir e compartilhar ideias, status atualizado, e mais. Nós também temos ferramentas e informações que podem ajudar você a saber o que está sendo feito, e por quem.

+ +

Canais de comunicação

+ +

Há muitos caminhos que você pode engajar como membro da comunidade (como desenvolvedor ou como escritor), cada um tem algumas regras particulares de etiqueta.

+ +

Bugzilla

+ +

Quando escrever documentação para cobrir mudanças implementadas como um resultado de um bug no Bugzilla, você frequentemente interagirá com pessoas envolvidas naquele projeto. Seja claro para continuar o guia de etiqueta Bugzilla em mente em todas às vezes!

+ +

E-mail

+ +

Algumas vezes, uma troca de e-mail privado entre você e uma ou mais pessoas, é o caminho para seguir, se você possuir os endereços de e-mails deles.

+ +
+

Nota: Como regra geral, se alguém postou o endereço de e-mail pessoal em documentos sobre a tecnologia que você está documentando, ou deu a você o endereço de e-mail pessoal, ou geralmente tem um endereço de e-mail bem conhecido, então o e-mail torna-se uma abordagem aceitável como "primeiro contato". Se você precisa "escavar" mais sobre o assunto, provavelmente você deve tentar obter aguma permissão no Matrix ou em uma lista de discussão primeiro, a menos que você tenha esgotado todas as outras tentativas de entrar em contato.

+
+ +

Ferramenta de status de conteúdo

+ +

Nós temos muitas ferramentas úteis que fornecem informações sobre o status do conteúdo da documentação.

+ +
+
Painel de Controle (Dashboard ) para revisão
+
O painel de controle para revisão providencia uma ferramenta fantástica para revisar mudanças feitas para o conteúdo do MDN. Você pode ver as histórias recentes, ou escolher um período de tempo para vê-las, e filtrar resultados com base em características como localidade, nome de contribuidores, e tópicos. Uma vez que você está olhando para um conjunto de revisões, você pode ver as mudanças feitas em cada revisão, abrir rapidamente a página, ver um histórico completo ou até reverter as alterações (se você tiver esses privilégios).
+
Visão geral do status da documentação
+
Nossa visão geral do status da documentação página providencia uma lista de todas as áreas do MDN que você tem configurado pela trilha de status, com informações sobre como muitas páginas são necessárias diferentes tipos de trabalho feito. Clique através de um particular tópico de área para ver detalhadas listas de conteúdo que necessitam trabalhar, tais como páginas que não tem tags, ou são tags com indicadores que certos tipos de trabalhos necessários para ser feito. Você pode mesmo ver listas de páginas que não tem sido atualizado em um longo tempo e pode se desatualizado, tão bem quanto uma lista de bugs que tem sido sinalizado como impactante na documentação daquela área.
+
Documentação dos planos de projetos
+
Nós temos um número de projetos escritos que estão no estágio de planejamento, ou são largos e em progresso, para o qual nós temos escrito documento de planejamento para ajudar-nos a guardar a trilha daquilo que nós precisamos fazer.
+
MDN Trello board
+
The MDN staff writers use a Trello board to manage current and future documentation projects. You can take a look to see what we're doing and how it's going, and you can see what projects we'd like to see happen soon. Some of those will be taken on by staff writers, but you should feel free to take one over if you like! For more information about how this board is used and how you can use it, you can read this page.
+
+ +

A comunidade de desenvolvimento

+ +

Possivelmente o mais importante relacionamento para desenvolver e manter, como um membro da comunidade de escrita do MDN, são aqueles que você desenvolve e sustenta com os desenvolvedores. Eles criam o software que nós estamos desenvolvendo, mas eles são também os mais usuais recursos de informações que nós temos. É crucial que nós mantenhamos bons relacionamentos com os desenvolvedores, pois são como você, vão responder suas questões rapidamente, precisamente, e completamente!

+ +

Em adição, você representa a comunidade de escrita MDN.

+ +

Por favor ajude a garantir que nós mantenhamos nosso excelente relacionamento de trabalho com a equipe dev para fazer toda a interação entre eles e a equipe de escrita seja ótima.

+ +

Em uma nota de relato, um grande caminho para encontrar a pessoa certa para falar olhe nas listas dos responsáveis dos módulos.

+ +

A comunidade de escrita

+ +

A comunidade de escrita é muito grande. Enquanto o número de frequentes extremos, ou contribuidores de grande escala é relativamente pequeno, Há muitas dezenas ou centenas de pessoas que contribuem de vez em quando. Felizmente, estas são grandes pessoas maravilhosas com um genuíno amor da web, Mozilla, e/ou documentação, e interagem com eles e quase sempre muito bonito.

+ +

Veja o artigo una a comunidade para mais informações sobre a comunidade MDN.

+ +

Veja também

+ + diff --git a/files/pt-br/orphaned/mdn/contribute/howto/create_an_mdn_account/index.html b/files/pt-br/orphaned/mdn/contribute/howto/create_an_mdn_account/index.html new file mode 100644 index 0000000000..369f018ce5 --- /dev/null +++ b/files/pt-br/orphaned/mdn/contribute/howto/create_an_mdn_account/index.html @@ -0,0 +1,43 @@ +--- +title: Como criar uma conta na MDN +slug: MDN/Contribute/guia/Create_an_MDN_account +tags: + - Conta + - Guia(2) + - Início(2) + - Novato + - como fazer +translation_of: MDN/Contribute/Howto/Create_an_MDN_account +--- +
{{MDNSidebar}}
+ +

Para fazer quaisquer alterações sobre o conteúdo do MDN (tanto editando uma página como contribuindo com uma demonstração), você precisará de um perfil MDN. Não se preocupe, você não precisa de um perfil se tudo o que você pretende é ler e pesquisar no MDN! Esse guia simples vai ajudá-lo a configurar seu perfil MDN.

+ +
Por que o MDN precisa do meu endereço de email?
+
+Seu endereço de email é usado para recuperação da conta, e se necessário por administradores do MDN para contatá-lo sobre sua conta ou sua atividade no site.
+
+Além disso, você pode opcionalmente inscrever-se para receber notificações (como quando uma página específica é modificada) e mensagens (por exemplo, se você optar por se juntar ao nosso time de testes beta, você poderá receber email sobre novas funcionalidades que precisam ser testadas).
+
+Seu endereço de email nunca é mostrado no MDN e será usado apenas de acordo com nossa política de privacidade.
+ +

Assim que você tiver decidido que quer contribuir para o MDN, aqui está tudo que você deve fazer para configurar o seu perfil:

+ +
    +
  1. No topo de qualquer página no MDN você vai encontrar um botão chamado "Entrar". Passe o seu mouse sobre ele(ou toque nele caso você esteja em um dispositivo móvel) para mostrar uma lista de serviços de autenticação que disponibilizamos para se inscrever no MDN.
    2. +
  2. Selecione um serviço com o qual você irá se inscrever. Atualmente, somente a inscrição com o GitHub está disponível. Note que, se você selecionar o GitHub, um vínculo com a sua conta do GitHub será incluída em seu perfil público na página pessoal do MDN.
    3. +
  3. Siga os passos do serviço para conectar sua conta ao MDN.
    4. +
  4. Uma vez que o serviço de autenticação retorná-lo ao MDN, será solicitado a você que entre com seu nome de usuário e endereço de email. Seu nome de usuário será mostrado publicamente para creditá-lo sobre trabalhos que você concluiu. Não use o seu endereço de email como seu nome de usuário.
    5. +
  5. Clique no botão "Criar meu perfil MDN".
    6. +
  6. Se o endereço de email que você especificou no passo 4 não é o mesmo que você usa no serviço de autenticação, você precisará checar seu email e clicar no link do email de confirmação que foi enviado para você.
    7. +
+ +

É isso! Você adquiriu uma conta MDN, e você pode imediatamente editar ou marcar páginas e postar demonstrações!

+ +

Você pode clicar no seu nome no topo de qualquer página MDN para ver o seu perfil público. A partir de lá, você pode clicar o botão de "Editar" para fazer modificações ou adições no seu perfil, assim você pode compartilhar mais sobre seus interesses, adicionar links para sua conta do Twitter ou blog, e assim por diante.

+ +
+

Observação: Novos nomes de usuário não podem conter espaços ou o caractere "@". Tenha em mente que o seu nome de usuário será mostrado publicamente para identificar o trabalho que você fez!

+
+ +

 

diff --git a/files/pt-br/orphaned/mdn/contribute/howto/do_a_technical_review/index.html b/files/pt-br/orphaned/mdn/contribute/howto/do_a_technical_review/index.html new file mode 100644 index 0000000000..45d49fbc55 --- /dev/null +++ b/files/pt-br/orphaned/mdn/contribute/howto/do_a_technical_review/index.html @@ -0,0 +1,52 @@ +--- +title: Como fazer uma revisão técnica +slug: MDN/Contribute/guia/Do_a_technical_review +tags: + - Documentação + - Guía + - MDN Meta + - Revisão + - como fazer +translation_of: MDN/Contribute/Howto/Do_a_technical_review +--- +
{{MDNSidebar}}

Uma Revisão técnica consiste em revisar a precisão técnica e a integridade de um artigo e corrigi-lo, se necessário. Se um escritor de um artigo procura alguém para verificar o conteúdo técnico do artigo, então ele marca a opção "Análise técnica" durante a edição. Muitas vezes, o escritor contata um engenheiro específico para realizar a revisão técnica, mas qualquer pessoa com experiência técnica no tópico pode fazer um.

+ +

Este artigo descreve como realizar uma revisão técnica, ajudando assim a garantir que o conteúdo do MDN seja exato.

+ +
+
Como é essa tarefa?
+
Revisar e corrigir artigos com precisão técnica e completude.
+
Onde deve ser feita?
+
Em artigos específicos aonde estão marcados como uma revisão técnica.
+
O que você precisa saber para fazer a tarefa?
+
+
    +
  • Conhecimento avançado (especialista) sobre o tópico do artigo que você está revisando. Se a leitura do artigo não lhe ensinou nada de novo, considere-se um especialista.
    • +
  • Como editar um artigo wiki no MDN
    • +
+
+
Quais são os passos para fazê-lo?
+
+
    +
  1. Escolha um artigo para revisar: +
      +
    1. Vá até a lista de páginas que necessitam de revisão técnica. Lá estará listado todas as páginas as quais uma revisão técnica foi solicitada.
      2. +
    2. Escolha uma página cujo tópico você conheça muito.
      3. +
    3. Clique no link do artigo para carregar a página.
      4. +
    +
    2. +
  2. Leia o artigo, prestando atenção aos detalhes técnicos: o artigo está correto? Falta alguma coisa? Não hesite em mudar para uma página diferente se o primeiro que você escolher não se adequar a você.
    3. +
  3. Se não houver erros, você não precisa editar o artigo para marcá-lo como revisado. Procure a caixa "revisão rápida" na barra lateral esquerda da página. Esta caixa amarela lista todas as revisões pendentes e permite que você desmarque a revisão já realizada. Em caso de uma revisão técnica solicita será apresentado desse modo:
    +
    4. +
  4. Desmarque a opção Técnico e clique em salvar.
    5. +
  5. Se você encontrar erros que precisam ser corrigidos, você também pode solicitar uma nova revisão apartir do editor. Aqui estão os passos: +
      +
    1. Para editar a página clique no botão editar no canto superior da página; desse modo você estará acessando o editor do MDN.
      2. +
    2. Corrija qualquer informação técnica que não esteja correta e/ou adicione qualquer informação importante que esteja faltando.
      3. +
    3. Digite um Comentário da revisão na parte inferior do artigo. Esta é uma breve mensagem que descreve o que você fez, como "Revisão técnica concluída". Se você corrigiu as informações, inclua isso em seu comentário, por exemplo, "Análise técnica e descrições de parâmetros fixos". Isso ajuda outros contribuidores e editores de sites a saber o que você mudou e por quê. Você também pode mencionar se houve partes específicas que você não se sentiu qualificado para revisar.
      4. +
    4. Clique no botão PUBLICAR.
      5. +
    +
    6. +
+ Parabéns! Você terminou sua primeira revisão técnica. Obrigado pela ajuda!
+
diff --git a/files/pt-br/orphaned/mdn/contribute/howto/do_an_editorial_review/index.html b/files/pt-br/orphaned/mdn/contribute/howto/do_an_editorial_review/index.html new file mode 100644 index 0000000000..687072f228 --- /dev/null +++ b/files/pt-br/orphaned/mdn/contribute/howto/do_an_editorial_review/index.html @@ -0,0 +1,55 @@ +--- +title: Como fazer uma revisão editorial +slug: MDN/Contribute/guia/Do_an_editorial_review +tags: + - Documentação + - Guia(2) + - MDN Meta + - Revisão + - como fazer +translation_of: MDN/Contribute/Howto/Do_an_editorial_review +--- +
{{MDNSidebar}}
+ +

A revisão editorial consiste em corrigir erros gramaticais e no modo de se expressar em um artigo. Nem todos contribuidores são experientes em linguagens, mas, independentemente dos seus conhecimentos, terão contribuído com artigos extremamente úteis, que precisam da aplicação de técnicas de revisão; Isso é feito em uma revisão editorial.

+ +

Esse artigo descreve como fazer uma revisão editorial, assim ajudando para assegurar que o conteúdo do MDN é preciso.

+ +
+
Qual é a tarefa?
+
Edição e revisão de artigos que estiverem marcados como "precisando de revisão editorial."
+
Onde é que isso precisa ser feito?
+
Em artigos específicos que são marcados como "precisando de revisão editorial."
+
O que é preciso conhecer para fazer essa tarefa?
+
Você precisa ter um bom dominio do idioma Ingles e habilidades de ortografia e gramática. Uma revisão editorial consiste em garantir que a gramática, ortografia e redação estejão corretas e fazendo sentido; E que o guia de estilo de escrita MDN seja seguido.
+
Quais são os passos a seguir?
+
+
    +
  1. Escolha um artigo para revisão: +
      +
    1. Vá para a lista de artigos que precisam de revisão editorial.  Essa lista contém todas as páginas que precisam de revisão editorial.
      2. +
    2. Escolha uma página que tenha título em português que não comece com Template:(Template: Páginas que contém macro-códigos MDN)
      3. +
    3. Clique no link do artigo para carregar a página.
      4. +
    +
    2. +
  2. Quando a página estiver carregada, clique no botão Editar próximo ao topo da página; Isso colocará você no editor MDN. Não hesite em trocar para uma página diferente se você não entendeu bem a página atual.
    3. +
  3. Se não houver erros, você não precisa editar o artigo para marca-lo como revisado. Olhe para uma caixa de "revisão rápida" a esquerda da barra de navegação:
    4. +
+ +

               Selecione a caixa Editorial , e clique em Review Completed.

+ +

4. Se você precisa consertar erros que precisam correção:

+ +
    +
  1. Clique no botão Editar próximo ao topo da página; Isso colocará você no editor MDN.
    2. +
  2. Corrija todas palavras e a gramática ou erros de uso.
    3. +
  3. Digite um Comentário de Revisão na parte de baixo do artigo, algo como 'Editorial revisado, foram corrigidos alguns erros de gramática e ortografia'.
    4. +
  4. Tire a seleção da caixa Editorial abaixo do Revisão necessária?
    5. +
  5. Clique no botão Salvar alterações.
    6. +
+ +
+

Por razões de perfomance, sua edição pode não aparecer logo na página.

+
+
+
diff --git a/files/pt-br/orphaned/mdn/contribute/howto/set_the_summary_for_a_page/index.html b/files/pt-br/orphaned/mdn/contribute/howto/set_the_summary_for_a_page/index.html new file mode 100644 index 0000000000..91ac82e8ea --- /dev/null +++ b/files/pt-br/orphaned/mdn/contribute/howto/set_the_summary_for_a_page/index.html @@ -0,0 +1,61 @@ +--- +title: Como definir o resumo de uma página +slug: MDN/Contribute/guia/Set_the_summary_for_a_page +tags: + - Como + - Guia(2) + - MDN Meta +translation_of: MDN/Contribute/Howto/Set_the_summary_for_a_page +--- +
{{MDNSidebar}}

Você pode definir o sumário de uma página no MDN, para ser usado de várias maneiras, incluindo em resultados de pesquisa, em outras páginas MDN como tópico de página de regiões, e em dicas. E o texto deve fazer sentido tanto ao contexto da página, como quando mostrado em outro contexto, sem o restante do conteúdo da página.

+ +

Um sumário pode ser bem definido com a página. Caso não seja bem definido, normalmente a primeira frase é usada, e nem sempre esta é a melhor maneira de se apresentar o conteúdo da página.

+ + + + + + + + + + + + + + + + + + + + +
Qual é a tarefa?Marcando o texto dentro de uma página que deve ser usado como seu resumo em outros contextos; esta tarefa pode incluir, se necessário escrever um texto adequado.
Onde isto deve ser feito?Em páginas que não possuem um resumo ou têm um resumo menos do que ótimo.
O que você deve saber para fazer a tarefa?Capacidade de usar o editor MDN; boas habilidades de escrita em inglês; familiaridade suficiente com o tema da página para escrever um bom resumo.
Quais são os passos a fazer? +
    +
  1. Escolha uma página para fazer o resumo: +
      +
    1. Na página MDN documentation status, clique sob o link Sections para um tema que você conhece um pouco sobre (por exemplo, HTML):
      +
      2. +
    2. Na página de status da documentação do tópico, clique no cabeçalho de páginas na tabela de 
      3. +
    3. Resumo. Isso leva você a um índice de todas as páginas em que seção do tópico; Ele mostra a página 
      4. +
    4. de links na coluna da esquerda e as tags e resumos na coluna à direita:
      5. +
      6. +
    6. Escolha uma página que está faltando um resumo, ou que tem um resumo fraco:
      +
      7. +
    7. Clique no link para ir para essa página.
      8. +
    +
    2. +
  2. Clique em Editar para abrir a página no editor MDN.
    3. +
  3. Procure uma frase ou duas, que funcionam como um resumo fora de contexto. Se necessário, edite o conteúdo existente para criar ou modificar frases para ser um bom resumo.
    4. +
  4. Selecionar o texto a ser usado como um resumo.
    5. +
  5. Nos estilos de elementos gráficos da barra de ferramentas do editor, selecione Resumo SEO. (No código fonte da página, isso cria uma {{HTMLElement("span")}} elemento com class = "seoSummary " em torno do texto selecionado.)
    +
    6. +
  6. Salve suas alterações com um comentário de revisão em como "Definir a página Resumo."
    7. +
+
+ +

 

+ +

 

+ +

 

diff --git a/files/pt-br/orphaned/mdn/contribute/howto/tag_javascript_pages/index.html b/files/pt-br/orphaned/mdn/contribute/howto/tag_javascript_pages/index.html new file mode 100644 index 0000000000..7c6f94ac07 --- /dev/null +++ b/files/pt-br/orphaned/mdn/contribute/howto/tag_javascript_pages/index.html @@ -0,0 +1,84 @@ +--- +title: Como marcar páginas de JavaScript +slug: MDN/Contribute/guia/Tag_JavaScript_pages +tags: + - Como + - Guia(2) + - JavaScript + - MDN Meta +translation_of: MDN/Contribute/Howto/Tag_JavaScript_pages +--- +
{{MDNSidebar}}

O tagueamento consiste na adição de meta-informações para as páginas de modo que o conteúdo relacionado possa ser agrupado, como por exemplo em uma ferramenta de pesquisa.

+ + + + + + + + + + + + + + + + +
E onde isso precisa ser feito?Dentro de páginas especificas relacionadas com Javascript e sem marcação.
O que é preciso saber para fazer a tarefa ? +
    +
  • O basico de javascript como saber o que é um metodo ou uma propriedade.
    • +
+
Quais são os passos para fazê-lo? +
    +
  1. Escolha uma das paginas na lista 'linkada' acima.
    2. +
  2. Click no link do artigo e carregue a página.
    3. +
  3. Uma vez que a página foi carregada, clique no botão Editar no topo, isso deve lhe posicionar no editor MDN.
    4. +
  4. Pelo menos uma tag Javascript deve ser adicionada. Aqui estão algumas outras tags possíveis para adicionar: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    TagA página que está em uso.
    Methodmétodo
    PropertyPropriedade
    prototypeprotótipo
    Object type namemétodo de um objeto; por exemplo String.fromCharCode deve ser a sequência da tag String
    ECMAScript6 and Experimentalrecursos adicionados na nova versão do ECMAScript
    Deprecatedrecursos obsoletos (cujo o uso é desencorajado, mas ainda suportada)
    Obsoleterecursos obsoletos (que não são mais suportados em browsers modernos)
    othersver as normas de tagueamento MDN para aplicar outras tags possíveis.
    +
    5. +
  5. Salve com um comentário.
    6. +
  6. E está pronto!
    7. +
+
diff --git a/files/pt-br/orphaned/mdn/contribute/howto/write_an_article_to_help_learn_about_the_web/index.html b/files/pt-br/orphaned/mdn/contribute/howto/write_an_article_to_help_learn_about_the_web/index.html new file mode 100644 index 0000000000..7754f741b6 --- /dev/null +++ b/files/pt-br/orphaned/mdn/contribute/howto/write_an_article_to_help_learn_about_the_web/index.html @@ -0,0 +1,114 @@ +--- +title: Como escrever um artigo para ajudar as pessoas aprender sobre a Web +slug: MDN/Contribute/guia/Escreva_um_artigo_para_ajudar_aprender_sobre_a_Web +tags: + - Guía + - MDN Meta + - aprendizado + - como fazer +translation_of: MDN/Contribute/Howto/Write_an_article_to_help_learn_about_the_Web +--- +
{{MDNSidebar}}
+ +

MDN's Área de aprendizado é a nossa casa para artigos que introduzem conceitos Web para novos desenvolvedores. Uma vez que seu conteúdo é voltado para iniciantes, este é um ótimo lugar para compartilhar seu conhecimento e ajudar visitantes a conhecer a Web. É importante ter certeza que novos desenvolvedores podem seguir o conteúdo, então nós damos atenção especial para isto.

+ +

Este artigo explica como escrever para a  Área de aprendizado.

+ +

Como escrever um artigo na Área de aprendizado

+ +

Para começar a contribuir com seu conhecimento, simplesmente clique no botão verde e grande, então siga os cinco passos abaixo. Se você está procurando por ideias, por favor dê uma olhada no nosso quadro de time Trello!

+ +

Escreva um artigo de aprendizado

+ +

Este artigo pode não acabar exatamente no lugar certo, mas pelo menos no MDN. Se você deseja falar com alguém sobre mover ele para o lugar certo, por favor  Contate-nos.

+ +

Passo 1: Escreva uma linha-dupla

+ +

A primeira frase do seu artigo precisa resumir sobre qual conteúdo você irá falar e a segunda deve ser um pouco mais específica sobre os itens que você vai inserir no seu artigo. Por exemplo:

+ +
+

Enquanto que os arquivos {{glossary("HTML")}} contém conteúdo estruturado, {{Glossary("CSS")}}, outra grande tecnologia Web, faz o conteúdo aparecer do jeito que você quer. Neste artigo nós vamos cobrir como esta tecnologia funciona, e como escrever seu próprio exemplo básico.

+
+ +

Note como o exemplo explica brevemente que CSS é uma importante tecnologia Web usada para estilizar páginas. Isto é suficiente para o leitor ter uma boa ideia sobre o quê o artigo fala.

+ +

Porque os artigos da Área de Aprendizado primeiramente foca em iniciantes, cada artigo deve cobrir um tópico direto, então não sobrecarregará o leitor com muita informação nova. Se você não resumir o artigo em uma sentença, você pode estar tentando fazer muito em somente um artigo!

+ +

Passo 2: Adicionar uma top box

+ +

Então adicione uma top box para ajudar os leitores com dicas sobre onde eles estão no processo de aprendizagem.  Aqui é um exemplo de top box do "Entendendo URLs e suas estruturas". Você pode usar este artigo como um modelo quando estiver escrevendo o seu próprio.

+ + + + + + + + + + + + +
Pré-requisitos:Você primeiro precisa saber Como a Internet funciona, O que é um servidor Web, and Os conceitos por trás dos links na web.
Objetivo:Você vai aprender o que é uma URL e como ela funciona na Web.
+ +
+
Pré-requisitos
+
O que o leitor, principalmente, precisa saber para seguir este artigo? Quando possível, faça um link de cada pré-requisito para outro artigo da Área de Aprendizado cobrindo o conceito (a menos que este seja um artigo básico que não precisa de nenhum conhecimento anterior).
+
Objetivos
+
Esta seção explica brevemente o que o leitor vai aprender no curso da leitura. Este é um pouco diferente da linha-um; a linha-um resume o tópico do artigo, enquando a seção objetivos especificamente descreve o que o leitor pode esperar ao terminar de ler todo o artigo.
+
 
+
+ +
+

Nota: Para criar esta tabela você pode copiar e colar a tabela do exemplo acima, ou usar a ferramenta do editor do MDN Tabela. Se você escolher usar a ferramenta Tabela, você precisa especificamente adicionar uma classe CSS learn-box adicional a classe padrão standard-table. Para fazer isto, quando você criar ou editar as propriedades da tabela, vá no painel "Avançado" e no campo Classes mudar para "standard-table learn-box".

+
+ +

Passo 3: Escreva uma descrição completa

+ +

Próximo: escreva uma longa descrição que forneça uma visão geral do artigo, destacando os conceitos principais. Não esqueça de explicar por quê o leitor deve pegar seu tempo para aprender este tópico e ler seu artigo!

+ +

Passo 4: Vá fundo

+ +

Quando você tiver terminado com tudo isso, você pode finalmente ir fundo no tema. Você pode estruturar esta parde do seu artigo como você quiser (Por quanto sinta-se livre para consultar nosso guia de estilo). Esta é sua chance de brilhar! Entre nos detalhes explicando o tema que você está escrevendo. Forneça links de referência para a documentação completa, explique como a tecnologia funciona em detalhe, forneça detalhes da sintaxe e usabilidade, e mais. É com você!

+ +

Como um guia, aqui são algumas dicas de escrita para iniciantes:

+ + + +

Dê uma olhada nas primeiras seções do nosso artigo Funções - blocos reutilizáveis de código para uma boa seção descritiva.

+ +

Passo 5: Forneça material de "aprendizado ativo"

+ +

Para ilustrar o artigo e ajudar o leitor a entender melhor o que ele está aprendendo, esteja certo de fornecer exercícios, tutoriais e tarefas para completar. Tendo eles praticando, e ativamente usando e experimentando os conceitos que seu artigo explica, você pode ajudar a fixar a informação no cérebro do leitor.

+ +

Você pode escolher incluir os exemplos diretamente nas páginas como  exemplos ao vivo, ou fazer links para eles se eles não funciona como exemplos ao vivo. Se você está interessado em ajudar a criar estes materiais de valores, por favor leia o artigo Criar um exercício interativo para ajudar o Aprendendo a Web.

+ +

Se você não pode fornecer links para materiais de aprendizado ativo (você não conhece nenhum ou não tem tempo para criar), você deveria adicionar uma tag {{Tag("NeedsActiveLearning")}} para o artigo. Assim outros contribuintes podem encontrar artigos que precisam de materiais de aprendizado ativo e talvez ajudar você com isto.

+ +

Dê uma olhada no Aprendizado ativo: selecionando diferentes elementos para um exemplo de exercício de aprendizado interativo, ou Aprendizado ativo: Jogando com escopo para um estilo diferente de exercício que permite fazer download de um template no dispositivo do leitor e modificá-lo seguindo os passos fornecidos.

+ +

Passo 6: Tenha o artigo revisto e colocado no menu de navegação da Área de aprendizado

+ +

Depois de ter escrito seu artigo, deixe-nos saber para podermos dar uma olhada, fazer uma revisão e sugerir melhorias. Novamente, veja nossa seção Contato, é a melhor maneira de manter contato.

+ +

Outra parte na finalização do seu artigo é colocar ele na área principal no menu de navegação da Área de Aprendizado. Este menu é gerado pelo LearnSidebar macro, o qual você precisa de privilégios especiais para editar, então, novamente, converse com alguém do nosso time sobre adicionar isto.

+ +

Você deveria pelo menos adicionar isso na sua página - isto é feito adicionando a chamada do macro \{{LearnSidebar}} dentro de um parágrafo no topo da sua página

+ + + +

Artigos sugeridos

+ +

Então você quer contribuir, mas você não tem certeza sobre o que escrever?

+ +

O time da Área de aprendizado mantém um quadro Trello com ideias de artigos para escrever. Sinta-se livre para pegar um e começar a trabalhar!

+ +

 

+ +

 

diff --git a/files/pt-br/orphaned/mdn/contribute/processes/cross-team_collaboration_tactics/index.html b/files/pt-br/orphaned/mdn/contribute/processes/cross-team_collaboration_tactics/index.html new file mode 100644 index 0000000000..22b22715be --- /dev/null +++ b/files/pt-br/orphaned/mdn/contribute/processes/cross-team_collaboration_tactics/index.html @@ -0,0 +1,65 @@ +--- +title: Táticas de colaboração intra equipe para documentação +slug: MDN/Contribute/Collaboration_tactics +tags: + - Documentação + - Guia(2) + - Guía + - MDN + - Projeto MDC +translation_of: MDN/Contribute/Processes/Cross-team_collaboration_tactics +--- +
{{MDNSidebar}}
+ +

Uma coisa que aprendemos na MDN é que quando equipes de desenvolvimento e documentação de um dado projeto, API ou tecnologia trabalham próximas uma da outra—e juntas— a documentação ganha uma qualidade inacreditável. Este guia sugere algumas táticas para que equipes de desenvolvimento e documentação trabalhem de mãos dadas.

+ +
+

Nota: Este artigo é um trabalho em progresso, um documento aberto. Caso você conheça outras maneiras de integrar equipes de desenvolvimento e documentação, convidamos você à dividi-las conosco aqui!

+
+ +

Integrando-se

+ +

Idealmente, quando o desenvolvimento de uma nova tecnologia ou projeto são concebidos, a equipe de desenvolvimento avisa a equipe de documentação que algo novo está à caminho e precisará ser documentado. Algumas vezes não é isso que acontece, e a equipe MDN monitora a Bugzilla observando todo trabalho que precisará ser documentado, porém em um mundo perfeito, nós receberemos um aviso prévio de maneira mais direta.

+ +

A melhor maneira de notificar a equipe MDN sobre um novo projeto o qual precisamos ficar cientes é preenchendo uma requisição de documentação de defeito. Fornecer uma lista de contatos em conjunto com as respectivas dúvidas é uma ótima maneira de ajudar! Incluir links para os defeitos relacionados ao projeto também é uma grande ajuda.

+ +

Compartilhando informação

+ +

Existem diversas maneiras úteis e diferentes de compartilhar informação. Apresentamos algumas sugestões a seguir.

+ +

Defeitos

+ +

Certificar-se de que a equipe de documentação está ciente dos defeitos que refletem na documentação é de grande ajuda. O uso adequado das palavras-chaves de documentação e desenvolvimento e das tags de comentários leva tempo. Consulte Atualizando documentação para mais informações.

+ +

Reuniões

+ +

Equipes de desenvolvimento realizam reuniões frequentemente. Sempre que possível e necessário(e muitas vezes é bastante necessário), a equipe MDN tenta enviar alguém para assistir estas reuniões. Esta é uma boa maneira de saber o que esta acontecendo, como os horários estão dispostos, e assim por diante.

+ +

Além disso, os profisionais que trabalham em grandes áreas de documentação, tais como documentação de APIs Web, muitas vezes realizam reuniões para acompanhar a evolução da documentação. Estes profissionais adoram ter um desenvolvedor à disposição para participar de tais reuniões; acaba sendo incrivelmente útil para todos os envolvidos.

+ +

Estas reuniões geralmente são curtas e possuem uma agenda similar a esta:

+ +
    +
  1. Atualizações sobre o andamento das atividades de documentação.
    2. +
  2. Perguntas/atualizações da equipe de desenvolvimento para a equipe de documentação: pode incluir perguntas sobre a evolução de documentos específicos, informações sobre conteúdo específico que é urgentemente necessário, notas sobre problemas com conteúdo já existente, e assim por diante.
    3. +
  3. Perguntas/atualizações da equipe de documentação para a equipe de desenvolvimento: esta é uma oportunidade para a equipe de documentação perguntar sobre possíveis bugs, se alguém pode se disponibilizar para revisar algum documento específico, se há um engenheiro em específico que esteja disponível para responder perguntas sobre uma determinada API, esse tipo de coisa.
    4. +
+ +

Reuniões de documentação de APIs Web  têm sido realizadas por meses em Vidyo, com grande sucesso. Cada semana, a equipe de desenvolvimento da API Web têm pelo menos um membro (e muitas vezes dois) para a reunião, e temos sido extremamente produtivos, realizando as reuiniões em 15 minutos ou menos.

+ +

Semanas de trabalho

+ +

Convide os responsáveis pela documentação para acompanhar a equipe de desenvolvimento em uma semana de trabalho ou reunião. Isto tem muitas vantagens, incluindo:

+ + + +

Se você não sabe se existe um membro para documentação atribuído ao tópico da sua área acompanhando sua semana de trabalho, não hesite em enviar um e-mail para o líder da equipe de documentação, Eric Shepherd, e ele buscará saber se alguém poderá auxiliar. Ele buscará alguém lá (ou melhor, buscará um membro exlusivo para documentação no seu projeto)! Tenha em mente, porém, que a equipe de documentação é pequena, então encontrar alguém para acompanhar uma semana de trabalho em um curto prazo é uma tarefa complicada.

+ +

Páginas de estado de documentação

+ +

Grandes projetos de documentação na MDN agora utilizam páginas de estados a fim de acompanhar o que falta ser feito, e o que já foi feito, para conseguir realizar o trabalho. Tais páginas fornecem uma lista de tarefas a serem realizadas, bem como o estado de cada tarefa.

diff --git a/files/pt-br/orphaned/mdn/dashboards/index.html b/files/pt-br/orphaned/mdn/dashboards/index.html new file mode 100644 index 0000000000..0aab5076a9 --- /dev/null +++ b/files/pt-br/orphaned/mdn/dashboards/index.html @@ -0,0 +1,17 @@ +--- +title: Painéis +slug: MDN/Paineis +tags: + - MDN Meta + - Rascunho + - Visão Geral + - painéis +translation_of: MDN/Dashboards +--- +
{{MDNSidebar}}{{Draft}}
+ +

Aqui estão alguns painéis que exibem algumas métricas.

+ +

Saiba mais sobre nossos Editores

+ +

{{SubpagesWithSummaries}}

diff --git a/files/pt-br/orphaned/mdn/editor/basics/index.html b/files/pt-br/orphaned/mdn/editor/basics/index.html new file mode 100644 index 0000000000..5f06217a31 --- /dev/null +++ b/files/pt-br/orphaned/mdn/editor/basics/index.html @@ -0,0 +1,65 @@ +--- +title: Elementos de Interface do Editor +slug: MDN/Editor/Basics +translation_of: MDN/Editor/Basics +--- +
{{MDNSidebar}}
+ +

O editor WYSIWYG embutido no MDN foi projetado para fazer com que seja o mais fácil possível criar, editar, e aprimorar artigos e praticamente qualquer outra página do site. A janela do editor, como mostrada abaixo, consiste em oito áreas principais. Este guia oferece informações sobre cada seção para que você saiba como utilizar inteiramente nosso ambiente de edição.

+ +
+

Estamos constantemente trabalhando em melhorias para o MDN, então haverá momentos em que este documento ou as capturas de tela abaixo estejam um pouco desatualizados. Portanto, iremos atualizar este documento periodicamente, evitando que se torne inutilizável.

+
+ +

Screenshot of the editor UI (August 2017) with each section labeled

+ +

A interface do editor contém as seguintes seções, como mostrado acima. Clique abaixo para ler sobre cada seção do editor respectivamente.

+ + + +

Caixa de ediçao

+ +

A caixa de edição é, evidementente, onde você irá realmente produzir o seu texto.

+ +

Clicando com o botão direito na caixa de edição, exibe-se opções apropriadas adicionais dependendo de onde você clicar: clicar com o botão direito do mouse em uma tabela irá mostrar opções relacionadas à tabela e clicar com o botão direito em uma lista, irá apresentar opções sobre àquela lista, por exemplo. Por padrão o editor utiliza seu próprio menu quando você clica com o botão direito no editor. Para acessar o menu padrão do seu navegador (como acessar a lista de correções do corretor ortográfico do Firefox), mantenha pressionada a tecla Shift ou a tecla Control (tecla Command no Mac OS X) enquanto estiver clicando.

+ +

Quando estiver trabalhando na caixa de edição, você pode usar essas teclas de atalho.

+ +

Comentários de revisão

+ +

Depois de fazer suas alterações, é extremamente recomendável que você adicione um comentário para sua revisão. Ele ficará disponível no histórico de revisão da página, assim como no Painel de controle. Isto irá ajudar a explicar ou justificar suas alterações para os outros que revisarão o seu trabalho depois. Para adicionar um comentário de revisão, escrevá-o na caixa de comentário antes de clicar em um dos dois botões de Publicar na parte superior e inferior da página.

+ +

Existem algumas razões pelas quais isto é útil:

+ + + +

Review requests

+ +

The MDN community uses reviews to try to monitor and improve the quality of MDN's content. This works by setting a flag on an article indicating that a review is needed. You can learn more about technical reviews and editorial review in the How to guides.

+ +

To request a review on the article you've worked on, toggle on the checkbox next to the type of review that's needed. Technical reviews should be requested any time you make changes to the explanation of how something technical works, while editorial reviews are a good idea when you've made changes and would like someone to review your writing and style choices.

+ +

While selecting a review checkbox adds the article to the lists of those needing technical review or needing editorial review, it does not guarantee that anyone will immediately review the article. For technical reviews, it's a good idea to directly contact a subject-matter expert in the relevant technical area. For editorial reviews, you can post in the MDN discussion forum to request that someone review your changes.

+ +

Be sure to click one of the Publish buttons after making your selections, to commit your review request.

+ +

See also

+ + + + diff --git a/files/pt-br/orphaned/mdn/editor/index.html b/files/pt-br/orphaned/mdn/editor/index.html new file mode 100644 index 0000000000..289d09b69f --- /dev/null +++ b/files/pt-br/orphaned/mdn/editor/index.html @@ -0,0 +1,10 @@ +--- +title: Guia do editor MDN +slug: MDN/Editor +translation_of: MDN/Editor +--- +
{{MDNSidebar}}

O editor WYSIWYG (what-you-see-is-what-you-get) oferecido pela Mozilla Developer Network wiki torna fácil a contribuição de conteúdo novo. O guia de editor MDN fornece algumas informações sobre como usar o editor, assim como algumas informações sobre recursos úteis que podem melhorar sua produtividade. Por favor, certifique-se de ler (e está de acordo com) o Mozilla Terms antes de editar ou criar novas páginas.

+ +

O Guia de estilo MDN oferece informação sobre como formatar e estilizar o conteúdo em si, incluindo as nossas regras de gramática e ortografia preferenciais.

+

{{LandingPageListSubpages}}

+

{{EditorGuideQuicklinks}}

diff --git a/files/pt-br/orphaned/mdn/tools/page_regeneration/index.html b/files/pt-br/orphaned/mdn/tools/page_regeneration/index.html new file mode 100644 index 0000000000..16808c9615 --- /dev/null +++ b/files/pt-br/orphaned/mdn/tools/page_regeneration/index.html @@ -0,0 +1,32 @@ +--- +title: Page regeneration +slug: MDN/Tools/Page_regeneration +tags: + - Ferramentas + - Guia(2) + - MDN Meta + - Page-level +translation_of: MDN/Tools/Page_regeneration +--- +
{{MDNSidebar}}

O site da MDN cacheia as páginas para melhorar a performance. Como resultado, as mudanças que você salva nas páginas podem não aparecer imediatamente. Muitas vezes, mas nem sempre, o banner aparece na página indicando que uma atualização para aquela página está em progresso. Você pode fazer uma "atualização forçada" no seu navegador para recarregar a página do servidor, mas isso pode não ter efeito se a atualização no servidor não estiver completa.

+ +

Algumas páginas (especialmente landing pages) utilizam macros para gerar e atualizar o conteúdo automaticamente. Para landing pages, fazer isso assegura que novos artigos vão automaticamente ser listados na página, sem que um editor tenha que adicioná-los manualmente. Isso é bem conveniente para contribuidores de longas datas e evita que o trabalho dos novatos seja perdido aleatoriamente devido eles não saberem como o inserir o link hierarquicamente para seus artigos.

+ +

Isso também pode ser feito quando a transclusão de conteúdo de uma pátina para outras páginas (usando por exemplo, o macro {{TemplateLink("Page")}}).

+ +

Devido ao cache da MDN ter renderizado o conteúdo para melhorar a performance, mudanças feitas no material fonte (como a saída dos macros ou páginas transcluídas) não são automaticamente refletidas na páginas. Se você espera mudanças frequentes feitas nesses materiais fonte, você pode considerar habilitar a regeneração automática de páginas.

+ +

Para habilitar a regeneração automática de páginas:

+ +
    +
  1. Clique no botão Editar na página para entrar no modo de edição.
    2. +
  2. Abaixo do título da página, clique em Editar o título e propriedades localizado perto do título da página. Os metadados da página aparecerão.
    3. +
  3. Selecione um valor para Tempo máximo de regeneração. Esse valor determina o intervalo de tempo que as páginas serão refeitas, incluindo a reexecução de seus macros. Tipicamente, nós utilizamos de 4 a 8 horas. Para uma tecnologia em que a documentação está mudando rapidamente, você pode mudar para um número menor.
    4. +
  4. Salve suas mudanças para a página. É uma boa prática fazer a revisão dos comentários para descrever o que você fez, tipo: "Mudei o tempo máximo de renderização para 4 horas".
    5. +
+ +

Essa página vai ser regerada automaticamente no tempo que você especificou.

+ +
+

A opção "Editar títilo e propriedades da página" não está disponível enquanto você cria uma nova página. Você terá que salvar as alterações e reabrir a página para vê-la.

+
diff --git a/files/pt-br/orphaned/mozilla/add-ons/webextensions/temporary_installation_in_firefox/index.html b/files/pt-br/orphaned/mozilla/add-ons/webextensions/temporary_installation_in_firefox/index.html new file mode 100644 index 0000000000..16e718fc9c --- /dev/null +++ b/files/pt-br/orphaned/mozilla/add-ons/webextensions/temporary_installation_in_firefox/index.html @@ -0,0 +1,95 @@ +--- +title: Empacotando e Instalando +slug: Mozilla/Add-ons/WebExtensions/Empacotando_e_instalando +translation_of: Mozilla/Add-ons/WebExtensions/Temporary_Installation_in_Firefox +translation_of_original: Mozilla/Add-ons/WebExtensions/Packaging_and_installation +--- +

Packaging your extension

+ +
+

Nós estamos trabalhando em uma GUI  para empacotar e carregar extensões. Veja Bug 1185460 para mais informações. Enquanto isso, siga as etapas abaixo.

+
+ +

Firefox extensões são empacotados como arquivos XPI, que nada mais são arquivos ZIP mas com extensão ".xpi".

+ +

Uma dica para empacotar o arquivo você precisa "zipar" todos os arquivos que está na root do seu diretório.

+ +

Windows

+ +
    +
  1. Abra a pasta com seus arquivos da extensão.
    2. +
  2. Selecione todos os arquivos.
    3. +
  3. Clique com o direito e escolha Enviar para → Pasta Compactada.
    4. +
  4. Renomeie o arquivo de "something.zip" para "something.xpi".
    5. +
+ +

+ +

Mac OS X

+ +
    +
  1. Abra a pasta com seus arquivos da extensão.
    2. +
  2. Selecione todos os arquivos.
    3. +
  3. Clique com o direito e escolha Compress n Items.
    4. +
  4. Renomeie o arquivo de Archive.zip para something.xpi.
    5. +
+ +

+ +

Linux / Mac OS X Terminal

+ +
    +
  1. cd path/to/my-extension/
    2. +
  2. zip -r ../my-extension.xpi *
    3. +
+ +

Installing your extension

+ +
    +
  1. Digite no caminho de URL about:addons
    2. +
  2. Clique e araste o arquivo XPI para dentro da página, ou abra o menu de ferramentas e escolha "Install Add-On From File..."
    3. +
  3. Clique instalar no dialog que irá aparecer
    4. +
+ +

Instalando suas extensões no Firefox OS

+ +

You can install your extension from WebIDE running on a Desktop connected via USB or Wifi. Open "path/to/my-extension/" as a Packaged App in WebIDE.

+ +

When the manifest.json validation status is valid you will be able to Install and Run your extension on the attached Firefox OS device running a nightly build of Firefox OS.

+ +

The extension will first have to be enabled in Settings->Add-ons on the Firefox OS device.

+ +

Soluções de problemas

+ +

There are a few common problems that you might run into:

+ +

"Este add-on não poderá ser instalado porque não pode ser verificado."

+ + + +

"Este add-on não pode ser instalado porque pode está corrompido."

+ + + +

Nada aconteceu

+ + + +

Observe o console

+ +

Some additional error information relating to how your extension was extracted and loaded might be available in the Browser Console.

diff --git a/files/pt-br/orphaned/tools/add-ons/dom_inspector/index.html b/files/pt-br/orphaned/tools/add-ons/dom_inspector/index.html new file mode 100644 index 0000000000..6e70f0a1f6 --- /dev/null +++ b/files/pt-br/orphaned/tools/add-ons/dom_inspector/index.html @@ -0,0 +1,81 @@ +--- +title: DOM Inspector (Em Pt-Br) +slug: Tools/Add-ons/DOM_Inspector_Pt-Br +tags: + - DOM + - 'DOM:Tools' + - DOM_Inspector + - DOM_PT-BR + - Extensions + - Ferramentas + - Inspector + - Theme + - Tools + - Web + - Web Developer + - XUL + - 'XUL:Tools' + - dev + - xu +translation_of: Tools/Add-ons/DOM_Inspector +--- +
{{ToolsSidebar}}

O DOM Inspector (também conhecido como DOMi) é uma ferramenta de desennvolvimento usada para inspecionar, browse, e editar o DOM (Document Object Model) de documentos - usando páginas da web ou windows XUL . A hierarquia do DOM pode ser navegada usando dois paíneis (two-paned) janela que permite uma variedade de pontos de vista diferentes sobre o documento e todos os nós dentro.

+ +
+

Esta ferramenta é um add-on para XUL-based em aplicações como o Firefox e o Thunderbird. Se você está procurando o DOM inspector ele está incorporado no Firefox, consulte a documetação para o Page Inspector. 

+
+ +

Documentação

+ +
+
Introdução ao DOM Inspector
+
+
+
Aqui um tutorial que irá ajudá-lo a começar com o DOM Inspector.
+
+
+
+ +
+
DOM Inspector FAQ
+
Perguntas e Respostas comuns sobre o DOM Inspector.
+
+ +
+
Página DOM Inspector no MozillaZine
+
Mais informaçãoe sobre o DOM Inspector.
+
Como criar um DOM Inspector
+
Postagens sobre como criar o DOM Inspector do início
+
+ +

Obter DOM Inspector

+ +
+
Firefox & Thunderbird
+
Você pode Baixar e Instalar o DOM Inspector para o AMO web site. (Usuarios de navegador Thunderbird AMO em Firefox deve salvar o link de instalação, ou visitar a página do DOM Inspector para Thunderbird.).
+
+ +
+
Thunderbird 2
+
DOM Inspector para Thunderbird 2 está disponível para Thunderbird Add-ons. Ou, construa você mesmo no Thunderbird com as seguintes opções:
+
+ +
ac_add_options --enable-extensions="default inspector"
+ac_add_options --enable-inspector-apis
+
+ +
+
Mozilla Suite e SeaMonkey
+
Select Tools > Web Development > DOM Inspector.
+
Você pode instalar o painel lateral através de:
+
Edit > Preferences > Advanced > DOM Inspector
+
Então basta abrir o painel inspector e visitar um Web Site..
+
+ +

Relatar um bug no DOM Inspector

+ +

Use um nome conveniente "DOM Inspector" componente no Bugzilla.

+ +

Para descobrir o DOM Inspector code e onde vive, consulte o DOM Inspector lista de módulos (DOM Inspector module listing).

+ +

{{ languages( { "es": "es/DOM_Inspector", "it": "it/DOM_Inspector", "fr": "fr/Inspecteur_DOM", "ja": "ja/DOM_Inspector", "ko": "ko/DOM_Inspector", "pl": "pl/Inspektor_DOM" } ) }}

diff --git a/files/pt-br/orphaned/tools/add-ons/index.html b/files/pt-br/orphaned/tools/add-ons/index.html new file mode 100644 index 0000000000..97b6d72ed1 --- /dev/null +++ b/files/pt-br/orphaned/tools/add-ons/index.html @@ -0,0 +1,21 @@ +--- +title: Add-ons +slug: Tools/Add-ons +tags: + - Add-ons + - Monitor de WebSocket + - Mozilla + - dev +translation_of: Tools/Add-ons +--- +
{{ToolsSidebar}}

Ferramenta de desenvolvimento não incorporados ao Firefox, mas envia complementos separados (Add-ons).

+ +
+
Monitor de WebSocket
+
+
+
Examine os dados trocados em uma conexão de WebSockets.
+
+
+
 
+
diff --git a/files/pt-br/orphaned/tools/css_coverage/index.html b/files/pt-br/orphaned/tools/css_coverage/index.html new file mode 100644 index 0000000000..31d1c8be34 --- /dev/null +++ b/files/pt-br/orphaned/tools/css_coverage/index.html @@ -0,0 +1,136 @@ +--- +title: CSS Coverage +slug: Tools/CSS_Coverage +tags: + - CSS + - cobertura CSS +translation_of: Tools/CSS_Coverage +--- +
{{ToolsSidebar}}
+

Este componente é experimental e não está ainda avaliado no Firefox

+
+ +

CSS cobertura é um conjunto de comandos para Ferramentas de desenvolvimento Firefox que ajuda, desembaraçar a bagunça CSS pelo CSS que não está sendo usado, e indicando as artes de seus arquivos CSS que são necessárias para a renderização inicial.

+ +

Essas ferramentas são de algum modo experimental porque a definição de "uso".é complicado, mas se espera que dará uma ajuda no trabalho do que está acontecendo.

+ +

O caminho que eles usam no geral é:

+ + + +

Um outro comando ("csscoverage oneshot") permite você efetivamente rodar ("csscoverage start; csscoverage stop").

+ +

O que "uso" significa?

+ +

TL;DR:

+ +

CSS cobertura checa se o tag#id.class seletor no exemplo abaixo existe em um conjunto de páginas web.

+ +
@media thing {
+  tag#id.class:hover {
+    foo: bar;
+  }
+}
+ +

Porque?

+ +

Supostamente seu CSS tem o seguinte: Se, durante o teste, seu mouse não entrar o span. Esta regra é usada?

+ +
<style>
+  span:hover {
+    color: purple;
+  }
+</style>
+
+<span>Test</span>
+
+ +

Tecnicamente span:hover não foi usado naquela palavra 'Test' não foi sempre colorido roxo, no entanto a cobertura CSS é realmente sobre estar vendo quais regras são relevantes ou irrelevantes, e span:hover claramente tem relevância para a página..

+ +

Similarmente, suponha que o seu CSS tenha o seguinte:

+ +
<style>
+  @media tv {
+    span {
+      color: purple;
+    }
+  }
+</style>
+
+<span>Test</span>
+
+ +

Você deve estar querendo plugar uma TV dentro de seu ambiente em ordem para medir relevância? 

+ +

Mas 'use' não é somente sobre relevância 

+ +

É a seguinte regra relevante:

+ +
<style>
+  span { }
+</style>
+
+<span>Test</span>
+
+ +

Isto pode ser argumentado que não é relevante porque não tem efeito na página e pode portanto se seguramente removido

+ +

No entanto acontece o seguinte:

+ +
<style>
+  span {
+    -o-text-curl: minor;
+  }
+</style>
+
+<span>Test</span>
+
+ +

Conhecendo se isto é ou não provável requer o uso de mecanismo de pesquisa e alguma técnica analítca, e pode até mesmo saber a versão do browser suportado em seu site. Estas são todas consideradas além do escopo desta ferramenta até a singularidade.

+ +

Isto também explica o porquê da div de regra é considerada "usada" no seguinte exemplo.

+ +
<style>
+  div { color: red; }
+  span { color: blue; }
+</style>
+
+<div><span>Test</span></div>
+
+ +

Pode ser argumentado que a div em regra não é usada desde que não afete a renderização final da página, no entanto considere esta alternativa definição:

+ +
<style>
+  div { color: red; border: none; }
+  span { color: blue; }
+</style>
+
+ +

Dífícil saber se a borda em regra é usada, e há muitas outras variações; considere opacidade, visibilidade e conversão de cor ao qual está mais complicando a definição de "uso". Para guardar uma coisa simples, "uso" significaque o seletor acerta um elemento.

+ +

Claramente se uma folha de estilo que você alterou durante um teste contém uma regra para um particular página que não é visto durante o teste, então nós marcaremos que esta regra é não "usada" apesar de haver sido vezes alterado. Então vale dobrar  checando antes de você remover as regras do arquivo CSS.

+ +

Ressalvas

+ +

Tenha consciência destas coisas:

+ + + +

Erros

+ +

Nós estamos trabalhando em um número de imortantes bugs ( erros ):

+ + diff --git a/files/pt-br/orphaned/tools/debugger_(before_firefox_52)/disable_breakpoints/index.html b/files/pt-br/orphaned/tools/debugger_(before_firefox_52)/disable_breakpoints/index.html new file mode 100644 index 0000000000..a4e9aa924c --- /dev/null +++ b/files/pt-br/orphaned/tools/debugger_(before_firefox_52)/disable_breakpoints/index.html @@ -0,0 +1,19 @@ +--- +title: Desabilitar breakpoints +slug: Tools/Debugger_(before_Firefox_52)/Disable_breakpoints +tags: + - breakpoint + - breakpoints +translation_of: Tools/Debugger_(before_Firefox_52)/Disable_breakpoints +--- +
{{ToolsSidebar}}

Para desabilitar um breakpoint, desmarqueo check box próximo ao breakpoint's entrada no Source list pane:

+ +

+ +

Alternativamente, ativar o menu de contexto enquanto o ponteiro do mouse estiver sobre a entrada do breakpoint no source list pane, e selecione "Desabilitar breakpoint".

+ +

Você pode também remover um brekpoint somente apertando na seta que o representa.

+ +

Para desabilitar/habilitar todos os breakpoints, use o "Toggle all breakpoints" botão no Source list pane:

+ +

diff --git a/files/pt-br/orphaned/tools/debugger_(before_firefox_52)/index.html b/files/pt-br/orphaned/tools/debugger_(before_firefox_52)/index.html new file mode 100644 index 0000000000..7d06312bdc --- /dev/null +++ b/files/pt-br/orphaned/tools/debugger_(before_firefox_52)/index.html @@ -0,0 +1,58 @@ +--- +title: Debugger (before Firefox 52) +slug: Tools/Debugger_(before_Firefox_52) +tags: + - NeedsTranslation + - TopicStub +translation_of: Tools/Debugger_(before_Firefox_52) +--- +
{{ToolsSidebar}}
+

This page describes the JavaScript Debugger as it appears before Firefox 52.

+ +

See what it looks like from Firefox 52 onwards.

+
+ +

The JavaScript Debugger enables you to step through JavaScript code and examine or modify its state to help track down bugs.

+ +

You can use it to debug code running locally in Firefox or running remotely, for example in a Firefox OS device or Firefox on Android. See remote debugging to learn how to connect the debugger to a remote target.

+ +

{{EmbedYouTube("sK8KU8oiF8s")}}

+ +
+

User Interface Tour

+ +

To find your way around the debugger, here's a quick tour of the UI.

+ +
+

How to

+ +

To find out what you can do with the debugger, see the following how-to guides:

+ +
+ +
+ +
+

Reference

+ +
+ +
diff --git a/files/pt-br/orphaned/web/accessibility/jaws_issues_with_firefox/index.html b/files/pt-br/orphaned/web/accessibility/jaws_issues_with_firefox/index.html new file mode 100644 index 0000000000..65fe989377 --- /dev/null +++ b/files/pt-br/orphaned/web/accessibility/jaws_issues_with_firefox/index.html @@ -0,0 +1,11 @@ +--- +title: Problemas com JAWS no Firefox +slug: Web/Acessibilidade/Problemas_com_JAWS_no_Firefox +tags: + - Acessibilidade + - Obsolento +translation_of: Web/Accessibility/JAWS_Issues_with_Firefox +--- +

Problemas JAWS Firefox conhecidos

+ +

Esse artigo não é mais relevante. Por favor, veja o FAQ no site de suporte Mozilla.

diff --git "a/files/pt-br/orphaned/web/api/node/entendendo_o_uso_do_m\303\251todo_appendchild-javascript/index.html" "b/files/pt-br/orphaned/web/api/node/entendendo_o_uso_do_m\303\251todo_appendchild-javascript/index.html" new file mode 100644 index 0000000000..a05abeae88 --- /dev/null +++ "b/files/pt-br/orphaned/web/api/node/entendendo_o_uso_do_m\303\251todo_appendchild-javascript/index.html" @@ -0,0 +1,55 @@ +--- +title: Entendendo o uso do método appendChild em javascript +slug: Web/API/Node/Entendendo_o_uso_do_método_AppendChild-javascript +--- +
{{ApiRef("DOM")}}
+ +

Resumo

+ +

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

+ +

Sintaxe

+ +
var filho = elemento.appendChild(filho);
+ + + +

Descrição

+ +

O método appendChild devolve uma referência ao nó adicionado.

+ +

Exemplo

+ +
// Cria um novo elemento de parágrafo e adiciona-o ao final do documento
+var p = document.createElement("p");
+document.body.appendChild(p);
+ +

Notas

+ +

Se filho é uma referência a um nó existente no documento, appendChild vai movê-lo de sua posição atual para a nova posição (i.e, não é necessário remover o nó de seu pai atual antes de adicioná-lo a outro nó).

+ +

Isso também significa que um nó não pode estar em dois lugares do documento ao mesmo tempo. Assim, se o nó já tem um pai, ele é primeiro removido para, só então, ser adicionado na nova posição.

+ +

Você pode usar o método {{domxref("Node.cloneNode")}} para criar uma cópia do nó antes de adicioná-lo ao novo pai. (Note que cópias feitas com o método cloneNode não serão mantidas sincronizadas automaticamente)

+ +

Este método não permite mover nós entre documentos diferentes. Se você quiser adicionar um nó de um documento diferente (por exemplo para mostrar o resultado de uma requisição AJAX), você precisa primeiro usar o método {{domxref("document.importNode")}}.

+ +

appendChild() é um dos métodos fundamentais da programação para a web usando o DOM. O método appendChild() insere um novo nó na estrutura do DOM de um documento, e é a segunda parte do processo criar-e-adicionar tão importante na construção de páginas web programaticamente.

+ +

Especificação

+ + + +

Ver também

+ + diff --git "a/files/pt-br/orphaned/web/guide/css/css_media_queries_(consultas_de_m\303\255dia_em_css)/index.html" "b/files/pt-br/orphaned/web/guide/css/css_media_queries_(consultas_de_m\303\255dia_em_css)/index.html" new file mode 100644 index 0000000000..c2f5f9f4ce --- /dev/null +++ "b/files/pt-br/orphaned/web/guide/css/css_media_queries_(consultas_de_m\303\255dia_em_css)/index.html" @@ -0,0 +1,20 @@ +--- +title: Usando CSS media queries (consultas de mídia em CSS) +slug: Web/Guide/CSS/CSS_media_queries_(consultas_de_mídia_em_CSS) +tags: + - CSS + - Guía + - Iniciante + - media query +--- +

Uma media query (consulta de mídia) consiste de um tipo de mídia e de, ao menos, uma expressão que restringe o escopo dos estilos CSS pelo uso de propriedades de mídia, como width (largura), height (altura) e color (cor). Media queries, incluídas na especificação CSS3, permitem que a apresentação do conteúdo se adapte a uma variedade de dispositivos de exibição sem a necessidade de mudar o próprio conteúdo.

+ +

Sintaxe

+ +

Consultas de mídia consistem em tipos de mídia opcional e podem, de acordo com a especificação CSS3, conter entre nenhuma ou mais expressões, declararadas como propriedades de mídia, que podem conter condições de estado verdadeiras ou falsas. O resultado de uma query (consulta) será verdadeiro se o tipo de mídia especificado nela corresponder ao tipo do dispositivo onde o documento é exibido e todas as expressões contidas na consulta forem verdadeiras.

+ +

Fonte:

+ +

https://developer.mozilla.org/en-US/docs/Web/CSS/Media_Queries/Using_media_queries

+ +

 

diff --git a/files/pt-br/orphaned/web/html/element/command/index.html b/files/pt-br/orphaned/web/html/element/command/index.html new file mode 100644 index 0000000000..99a42fb9db --- /dev/null +++ b/files/pt-br/orphaned/web/html/element/command/index.html @@ -0,0 +1,129 @@ +--- +title: command +slug: Web/HTML/Element/command +translation_of: Web/HTML/Element/command +--- +

Sumário

+ +

O elemento command representa um comando que o usuário pode chamar.

+ +

Contexto de uso

+ + + + + + + + + + + + + + + + + + + + + + + + +
Categorias de conteúdoFlow content, phrasing content
Elementos permitidosNenhum, é um elemento vazio.
Omissão de tagDeve ter uma tag inicial, mas não deve ter uma tag final.
Elementos pais permitidosQualquer elemento que aceite phrasing content.
Documento normativoHTML5, section 4.11.3
+ +

Atributos

+ +

Como todos ou outros elementos HTML, esse elemento suporta os global attributes.

+ +
+
{{ htmlattrdef("checked") }}
+
Indica se o comando está selecionado ou não. Deve ser omitido a não ser que o atributo type seja checkbox ou radio.
+
{{ htmlattrdef("disabled") }}
+
Indica que o elemento não está disponível.
+
{{ htmlattrdef("icon") }}
+
Atribui uma figura para representar o comando.
+
{{ htmlattrdef("label") }}
+
O nome do comando, como será mostrado para o usuário.
+
{{ htmlattrdef("radiogroup") }}
+
Esse atributo dá o nome de um grupo de comandos, com type sendo radio, que vai ser ativado quando o comando for ativado. Esse atributo deve ser omitido a não ser que o atributo type seja radio.
+
{{ htmlattrdef("type") }}
+
Esse atributo indica o tipo do comando. Pode ter somente os seguintes valores: +
    +
  • +

    command ou vazio que é o estado padrão e indica que é um comando normal.

    +
    • +
  • +

    checkbox indica que o comando pode ser alternado utilizando uma caixa de seleção.

    +
    • +
  • +

    radio indica que o comando pode ser alternado utilizando uma radiobutton.

    +
    • +
+
+
+ +

Interface do DOM

+ +

Esse elemetno implementa a interface HTMLCommandElement.

+ +

Exemplos

+ +
<command type="command" label="Save" icon="icons/save.png" onclick="save()">
+
+ +

Compatibilidade de navegadores

+ +

{{ CompatibilityTable() }}

+ +
+ + + + + + + + + + + + + + + + + + + +
RecursoChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}
+
+ +
+ + + + + + + + + + + + + + + + + + + +
RecursoAndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}
+
+ +

 

+ +

{{ languages( { "zh-cn": "zh-cn/HTML/Element/command" } ) }}

diff --git a/files/pt-br/orphaned/web/html/favicon/index.html b/files/pt-br/orphaned/web/html/favicon/index.html new file mode 100644 index 0000000000..6b3bef6490 --- /dev/null +++ b/files/pt-br/orphaned/web/html/favicon/index.html @@ -0,0 +1,32 @@ +--- +title: favicon +slug: Web/HTML/favicon +--- +

 

+ +

 

+ +

Comentário da revisão

+ +
+

 

+ +

Diga-nos porque fez adições e alterações. É opcional, mas irá fazer com que o histórico da página seja mais fácil de entender.

+
+ +
+

É necessário revisão?

+ + +
+ +
+

 

+
+ +

Tags

+ +

 

diff --git "a/files/pt-br/orphaned/web/javascript/guide/cole\303\247\303\265es_chaveadas/index.html" "b/files/pt-br/orphaned/web/javascript/guide/cole\303\247\303\265es_chaveadas/index.html" new file mode 100644 index 0000000000..cb626865f8 --- /dev/null +++ "b/files/pt-br/orphaned/web/javascript/guide/cole\303\247\303\265es_chaveadas/index.html" @@ -0,0 +1,149 @@ +--- +title: Coleções chaveadas +slug: Web/JavaScript/Guide/Coleções_chaveadas +tags: + - Coleções + - Guía + - JavaScript + - Mapas +--- +
{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Indexed_Collections", "Web/JavaScript/Guide/Working_with_Objects")}}
+ +

This chapter introduces collections of data which are ordered by a key; Map and Set objects contain elements which are iterable in the order of insertion.

+ +

Maps

+ +

Map object

+ +

ECMAScript 6 introduces a new data structure to map values to values. A {{jsxref("Map")}} object is a simple key/value map and can iterate its elements in insertion order

+ +

The following code shows some basic operations with a Map. See also the {{jsxref("Map")}} reference page for more examples and the complete API. You can use a {{jsxref("Statements/for...of","for...of")}} loop to return an array of [key, value] for each iteration.

+ +
var sayings = new Map();
+sayings.set("dog", "woof");
+sayings.set("cat", "meow");
+sayings.set("elephant", "toot");
+sayings.size; // 3
+sayings.get("fox"); // undefined
+sayings.has("bird"); // false
+sayings.delete("dog");
+
+for (var [key, value] of sayings) {
+  console.log(key + " goes " + value);
+}
+// "cat goes meow"
+// "elephant goes toot"
+
+ +

Object and Map compared

+ +

Traditionally, {{jsxref("Object", "objects", "", 1)}} have been used to map strings to values. Objects allow you to set keys to values, retrieve those values, delete keys, and detect whether something is stored at a key. Map objects, however, have a few more advantages that make them better maps.

+ + + +

These two tips can help you to decide whether to use a Map or an Object:

+ + + +

WeakMap object

+ +

The {{jsxref("WeakMap")}} object is a collection of key/value pairs in which the keys are objects only and the values can be arbitrary values. The object references in the keys are held weakly meaning that they are target of garbage collection (GC) if there is no other reference to the object anymore. The WeakMap API is the same as the Map API.

+ +

One difference to Map objects is that WeakMap keys are not enumerable (i.e. there is no method giving you a list of the keys). If they were, the list would depend on the state of garbage collection, introducing non-determinism.

+ +

For more information and example code, see also "Why WeakMap?" on the {{jsxref("WeakMap")}} reference page.

+ +

One use case of WeakMap objects is to store private data for an object or to hide implementation details. The following example is from Nick Fitzgerald blog post "Hiding Implementation Details with ECMAScript 6 WeakMaps". The private data and methods belong inside the object and are stored in the privates WeakMap object. Everything exposed on the instance and prototype is public; everything else is inaccessible from the outside world because privates is not exported from the module

+ +
const privates = new WeakMap();
+
+function Public() {
+  const me = {
+    // Private data goes here
+  };
+  privates.set(this, me);
+}
+
+Public.prototype.method = function () {
+  const me = privates.get(this);
+  // Do stuff with private data in `me`...
+};
+
+module.exports = Public;
+
+ +

Sets

+ +

Set object

+ +

{{jsxref("Set")}} objects are collections of values. You can iterate its elements in insertion order. A value in a Set may only occur once; it is unique in the Set's collection.

+ +

The following code shows some basic operations with a Set. See also the {{jsxref("Set")}} reference page for more examples and the complete API.

+ +
var mySet = new Set();
+mySet.add(1);
+mySet.add("some text");
+mySet.add("foo");
+
+mySet.has(1); // true
+mySet.delete("foo");
+mySet.size; // 2
+
+for (let item of mySet) console.log(item);
+// 1
+// "some text"
+
+ +

Converting between Array and Set

+ +

You can create an {{jsxref("Array")}} from a Set using {{jsxref("Array.from")}} or the spread operator. Also, the Set constructor accepts an Array to convert in the other direction. Note again that Set objects store unique values, so any duplicate elements from an Array are deleted when converting.

+ +
Array.from(mySet);
+[...mySet2];
+
+mySet2 = new Set([1,2,3,4]);
+
+ +

Array and Set compared

+ +

Traditionally, a set of elements has been stored in arrays in JavaScript in a lot of situations. The new Set object, however, has some advantages:

+ + + +

WeakSet object

+ +

{{jsxref("WeakSet")}} objects are collections of objects. An object in the WeakSet may only occur once; it is unique in the WeakSet's collection and objects are not enumerable.

+ +

The main differences to the {{jsxref("Set")}} object are:

+ + + +

The use cases of WeakSet objects are limited. They will not leak memory so it can be safe to use DOM elements as a key and mark them for tracking purposes, for example.

+ +

Key and value equality of Map and Set

+ +

Both, the key equality of Map objects and the value equality of Set objects, are based on the "same-value-zero algorithm":

+ + + +

{{PreviousNext("Web/JavaScript/Guide/Indexed_Collections", "Web/JavaScript/Guide/Working_with_Objects")}}

diff --git a/files/pt-br/orphaned/web/javascript/guide/sintaxe_e_tipos/index.html b/files/pt-br/orphaned/web/javascript/guide/sintaxe_e_tipos/index.html new file mode 100644 index 0000000000..953a9543de --- /dev/null +++ b/files/pt-br/orphaned/web/javascript/guide/sintaxe_e_tipos/index.html @@ -0,0 +1,583 @@ +--- +title: Sintaxe e tipos +slug: Web/JavaScript/Guide/Sintaxe_e_tipos +--- +
{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Control_flow_and_error_handling")}}
+ +

Este capítulo trata sobre a sintaxe básica do JavaScript, declarações de variáveis, tipos de dados e literais.

+ +

Sintaxe básica

+ +

JavaScript pega emprestado a maior parte de sua sintaxe do Java, mas também é influenciado por Awk, Perl e Python.

+ +

JavaScript é case-sensitive e usa o conjunto de caracteres Unicode.

+ +

No JavaScript, instruções são chamadas de {{Glossary("Statement", "declarações")}} e são separadas por um ponto e vírgula (;). Espaços, tabulação e uma nova linha são chamados de espaços em branco. O código fonte dos scripts em JavaScript são lidos da esquerda para a direita e são convertidos em uma sequência de elementos de entrada como simbolos, caracteres de controle, terminadores de linha, comentários ou espaço em branco. ECMAScript também define determinadas palavras-chave e literais, e tem regras para inserção automática de ponto e vírgula (ASI) para terminar as declarações. No entanto, recomenda-se sempre adicionar ponto e vírgula no final de suas declarações; isso evitará alguns imprevistos. Para obter mais informações, consulte a referência detalhada sobre a gramática léxica do JavaScript.

+ +

Comentários

+ +

A sintaxe dos comentários em JavaScript é semelhante como em C++ e em muitas outras linguagens:

+ +
// comentário de uma linha
+
+/* isto é um comentário longo
+   de múltiplas linhas.
+ */
+
+/* Você não pode, porém, /* aninhar comentários */ SyntaxError */
+ +

Declarações

+ +

Existem três tipos de declarações em JavaScript.

+ +
+
{{jsxref("Statements/var", "var")}}
+
Declara uma variável, opcionalmente, inicializando-a com um valor.
+
{{experimental_inline}} {{jsxref("Statements/let", "let")}}
+
Declara uma variável local de escopo do bloco, opcionalmente, inicializando-a com um valor.
+
{{experimental_inline}} {{jsxref("Statements/const", "const")}}
+
Declara uma constante apenas de leitura.
+
+ +

Variáveis

+ +

Você usa variáveis como nomes simbólicos para os valores em sua aplicação. O nome das variáveis, chamados de {{Glossary("Identifier", "identificadores")}}, obedecem determinadas regras.

+ +

Um identificador JavaScript deve começar com uma letra, underline (_), ou cifrão ($); os caracteres subsequentes podem também ser números (0-9). Devido JavaScript ser case-sensitive, letras incluem caracteres de "A" a "Z" (maiúsculos) e caracteres de "a" a "z" (minúsculos).

+ +

Você pode usar a ISO 8859-1 ou caracteres Unicode tal como os identificadores å e ü. Você pode também usar as sequências de escape Unicode como caracteres e identificadores.

+ +

Alguns exemplos de nomes legais são Numeros_visitas, temp99, e _nome.

+ +

Declarando variáveis

+ +

Você pode declarar uma variável de três formas:

+ + + +

Classificando variáveis

+ +

Uma variável declarada usando a declaração var ou let sem especificar o valor inicial tem o valor  {{jsxref("undefined")}}.

+ +

Uma tentativa de acessar uma variável não declarada resultará no lançamento de uma exceção {{jsxref("ReferenceError")}}:

+ +
var a;
+console.log("O valor de a é " + a); // saída "O valor de a é undefined"
+console.log("O valor de b é " + b); // throws ReferenceError exception
+
+ +

Você pode usar undefined para determinar se uma variável tem um valor. No código a seguir, não é atribuído um valor de entrada na variável e a declaração if será avaliada como verdadeira (true).

+ +
var input;
+if(input === undefined){
+  facaIsto();
+} else {
+  facaAquilo();
+}
+
+ +

O valor undefined se comporta como falso (false), quando usado em um contexto booleano. Por exemplo, o código a seguir executa a função myFunction devido o elemento myArray ser undefined:

+ +
var myArray = [];
+if (!myArray[0]) myFunction();
+
+ +

O valor undefined converte-se para NaN quando usado no contexto numérico.

+ +
var a;
+a + 2;  // Avaliado como NaN
+
+ +

Quando você avalia uma variável nula, o valor nulo se comporta como 0 em contextos numéricos e como falso em contextos booleanos. Por exemplo:

+ +
var n = null;
+console.log(n * 32); // a saída para o console será 0.
+
+ +

Escopo de variável

+ +

Quando você declara uma váriavel fora de qualquer função, ela é chamada de variável global, porque está disponível para qualquer outro código no documento atual. Quando você declara uma variável dentro de uma função, é chamada de variável local,  pois ela está disponível somente dentro dessa função.

+ +

JavaScript antes do ECMAScript 6 não possuía escopo de declaração de bloco; pelo contrário, uma variável declarada dentro de um bloco de uma função é uma variável local (ou contexto global) do bloco que está inserido a função. Por exemplo o código a seguir exibirá 5, porque o escopo de x está na função (ou contexto global) no qual x é declarado, não o bloco, que neste caso é a declaração if. 

+ +
if (true) {
+  var x = 5;
+}
+console.log(x);  // 5
+
+ +

Esse comportamento é alterado, quando usado a declaração let introduzida pelo ECMAScript 6.

+ +
if (true) {
+  let y = 5;
+}
+console.log(y);  // ReferenceError: y não está definido
+
+ +

Hoisting

+ +

Outra coisa incomum sobre variáveis em JavaScript é que você pode utilizar a variável e declará-la depois, sem obter uma exceção. Este conceito é conhecido como hoisting; variáveis em JavaScript são num sentido "hoisted" ou lançada para o topo da função ou declaração. No entanto, as variáveis que são "hoisted" retornarão um valor undefined. Então, mesmo se você usar ou referir a variável e depois declará-la e inicializá-la, ela ainda retornará undefined.

+ +
/**
+ * Exemplo 1
+ */
+console.log(x === undefined); // exibe "true"
+var x = 3;
+
+/**
+ * Exemplo 2
+ */
+// returnará um valor undefined
+var myvar = "my value";
+
+(function() {
+  console.log(myvar); // undefined
+  var myvar = "local value";
+})();
+
+ +

Os exemplos acima serão interpretados como:

+ +
/**
+ * Exemplo 1
+ */
+var x;
+console.log(x === undefined); // exibe "true"
+x = 3;
+
+/**
+ * Exemplo 2
+ */
+var myvar = "um valor";
+
+(function() {
+  var myvar;
+  console.log(myvar); // undefined
+  myvar = "valor local";
+})();
+
+ +

Devido o hoisting, todas as declarações var em uma função devem ser colocadas no início da função. Essa recomendação de prática deixa o código mais legível.

+ +

Variáveis Globais

+ +

Variáveis globais são propriedades do objeto global. Em páginas web o objeto global é a {{domxref("window")}}, assim você pode configurar e acessar variáveis globais utilizando a sintaxe window.variavel. 

+ +

Consequentemente, você pode acessar variáveis globais declaradas em uma janela ou frame ou frame de outra janela. Por exemplo, se uma variável chamada phoneNumber é declarada em um documento, você pode consultar esta variável de um frame como parent.phoneNumber.

+ +

Constantes

+ +

Você pode criar uma constante apenas de leitura por meio da palavra-chave {{jsxref("Statements/const", "const")}}. A sintaxe de um identificador de uma constante é semelhante ao identificador de uma variável: deve começar com uma letra, underline ou cifrão e pode conter caracteres alfabético, numérico ou underline.

+ +
const prefix = '212';
+
+ +

Uma constante não pode alterar seu valor por meio de uma atribuição ou ao ser declarada novamente enquanto o script é executado. Deve ser inicializada com um valor.

+ +

As regras de escopo para as constantes são as mesmas para as váriaveis let de escopo de bloco. Se a palavra-chave const for omitida, o identificado é adotado para representar uma variável.

+ +

Você não pode declarar uma constante com o mesmo nome de uma função ou variável que estão no mesmo escopo. Por exemplo: 

+ +
// Isto irá causar um  erro
+function f() {};
+const f = 5;
+
+// Isto também irá causar um erro.
+function f() {
+  const g = 5;
+  var g;
+
+  //declarações
+}
+
+ +

Estrutura de dados e tipos

+ +

Tipos de dados

+ +

O mais recente padrão ECMAScript define sete tipos de dados:

+ + + +

Embora esses tipos de dados sejam uma quantidade relativamente pequena, eles permitem realizar funções úteis em suas aplicações.  {{jsxref("Object", "Objetos")}} e {{jsxref("Function", "funçõess")}} são outros elementos fundamentais na linguagem. Você pode pensar em objetos como recipientes para os valores, e funções como métodos que suas aplicações podem executar.

+ +

Conversão de tipos de dados

+ +

JavaScript é uma linguagem dinamicamente tipada. Isso significa que você não precisa especificar o tipo de dado de uma variável quando declará-la, e tipos de dados são convertidos automaticamente conforme a necessidade durante a execução do script. Então, por exemplo, você pode definir uma variável da seguinte forma:

+ +
var answer = 42;
+
+ +

E depois, você pode atribuir uma string para a mesma variável, por exemplo:

+ +
answer = "Obrigado pelos peixes...";
+
+ +

Devido JavaScript ser dinamicamente tipado, essa declaração não gera uma mensagem de erro.

+ +

Em expressões envolvendo valores numérico e string com o operador +, JavaScript converte valores numérico para strings. Por exemplo, considere a seguinte declaração:

+ +
x = "A resposta é " + 42 // "A resposta é 42"
+y = 42 + " é a resposta" // "42 é a resposta"
+
+ +

Nas declarações envolvendo outros operadores,  JavaScript não converte valores numérico para strings. Por exemplo:

+ +
"37" - 7 // 30
+"37" + 7 // "377"
+
+ +

Convertendo strings para números

+ +

No caso de um valor que representa um número está armazenado na memória como uma string, existem métodos para a conversão.

+ + + +

parseInt irá retornar apenas números inteiros, então seu uso é restrito para a casa dos decimais. Além disso, é uma boa prática ao usar parseInt incluir o parâmetro da base. O parâmetro da base é usado para especificar qual sistema númerico deve ser usado.

+ +

Uma método alternativo de conversão de um número em forma de string é com o operador + (operador soma):

+ +
"1.1" + "1.1" = "1.11.1"
+(+"1.1") + (+"1.1") = 2.2
+// Nota: Os parênteses foram usados para deixar mais legível o código, ele não é requirido.
+ +

Literais

+ +

Você usa literais para representar valores em JavaScript. Estes são valores fixados, não variáveis, que você literalmente insere em seu script. Esta seção descreve os seguintes tipos literais:

+ + + +

Array literal

+ +

Um literal de array é uma lista de zero ou mais expressões, onde cada uma delas representam um elemento do array, inseridas entre colchetes ([]). Quando você cria um array usando um array literal, ele é inicializado  com os valores especificados como seus elementos, e seu comprimento é definido com o  número de elementos especificados.

+ +

O exemplo a seguir cria um array coffees com três elementos e um comprimento de três:

+ +
var coffees = ["French Roast", "Colombian", "Kona"];
+
+ +
+

Nota : Um array literal é um tipo de inicializador de objetos. Veja Usando inicializadores de Objetos.

+
+ +

Se um array é criado usando um literal no topo do script, JavaScript interpreta o array cada vez que avalia a expressão que contêm o array literal. Além disso, um literal usado em uma função é criado cada vez que a função é chamada.

+ +

Array literal são também um array de objetos. Veja  {{jsxref("Array")}} e Coleções indexadas para detalhes sobre array de objetos.

+ +

Vírgulas extras em array literal

+ +

Você não precisa especificar todos os elementos em um array literal. Se você colocar duas vírgulas em uma linha, o array é criado com undefined para os elementos não especificados. O exemplo a seguir cria um array chamado fish:

+ +
var fish = ["Lion", , "Angel"];
+
+ +

Esse array tem dois elementos com valores e um elemento vazio (fish[0] é "Lion", fish[1] é undefined, e fish[2] é "Angel" ).

+ +

Se você incluir uma vírgula à direita no final da lista dos elementos, a vírgula é ignorada. No exemplo a seguir, o comprimento do array é três. Não há nenhum myList[3]. Todas as outras vírgulas na lista indicam um novo elemento.

+ +
+

Nota : Vírgulas à direita podem criar erros em algumas versões de navegadores web antigos, é recomendável removê-las.

+
+ +
var myList = ['home', , 'school', ];
+
+ +

No exemplo a seguir, o comprimento do array é quatro, e myList[0] e myList[2] são undefined.

+ +
var myList = [ , 'home', , 'school'];
+
+ +

No exemplo a seguir, o comprimento do array é quatro, e myList[1] e myList[3] são undefined. Apenas a última vírgula é ignorada.

+ +
var myList = ['home', , 'school', , ];
+
+ +

Entender o comportamento de vírgulas extras é importante para a compreensão da linguagem JavaScript, no entanto, quando você escrever seu próprio código: declarar explicitamente os elementos em falta como undefined vai aumentar a clareza do código, e consequentemente na sua manutenção.

+ +

Literais Boolean

+ +

O tipo Boolean tem dois valores literal: true e false.

+ +

Não confunda os valores primitivos Boolean true e false com os valores true e false do objeto Boolean. O objeto Boolean é um invólucro em torno do tipo de dado primitivo. Veja {{jsxref("Boolean")}} para mais informação.

+ +

Inteiros

+ +

Inteiros podem sem expressos em decimal (base 10), hexadecimal (base 16), octal (base 8) e binário (base 2).

+ + + +

Alguns exemplos de inteiros literal são:

+ +
0, 117 and -345 (decimal, base 10)
+015, 0001 and -077 (octal, base 8)
+0x1123, 0x00111 and -0xF1A7 (hexadecimal, "hex" or base 16)
+0b11, 0b0011 and -0b11 (binário, base 2)
+
+ +

Para maiores informações, veja Literais numérico na referência Léxica.

+ +

Literais de ponto flutuante

+ +

Um literal de ponto flutuante pode ter as seguintes partes:

+ + + +

O expoente é um "e" ou "E" seguido por um inteiro, que pode ter sinal (precedido por "+" ou "-"). Um literal de ponto flutuante  deve ter no mínimo um dígito e um ponto decimal ou "e" (ou "E").

+ +

Mais sucintamente, a sintaxe é:

+ +
[(+|-)][digitos][.digitos][(E|e)[(+|-)]digitos]
+
+ +

Por exemplo:

+ +
3.1415926
+-.123456789
+-3.1E+12
+.1e-23
+
+ +

Objeto literal

+ +

Um objeto literal é uma lista de zero ou mais pares de nomes de propriedades e valores associados de de um objeto, colocado entre chaves ({}). Você não deve usar um objeto literal no início de uma declaração. Isso levará a um erro ou não se comportará conforme o esperado, porque o { será interpretado como início de um bloco.

+ +

Segue um exemplo de um objeto literal. O primeiro elemento do objeto car define uma propriedade, myCar, e atribui para ele uma nova string, "Saturn"; o segundo elemento, a propriedade getCar, é imediatamente atribuído o resultado de chamar uma função (carTypes("Honda")); o terceiro elemento, a propriedade especial, usa uma variável existente (sales).

+ +
var sales = "Toyota";
+
+function carTypes(name) {
+  if (name == "Honda") {
+    return name;
+  } else {
+    return "Sorry, we don't sell " + name + ".";
+  }
+}
+
+var car = { myCar: "Saturn", getCar: carTypes("Honda"), special: sales };
+
+console.log(car.myCar);   // Saturn
+console.log(car.getCar);  // Honda
+console.log(car.special); // Toyota
+
+ +

Além disso, você pode usar um literal numérico ou string para o nome de uma propriedade ou aninhar um objeto dentro do outro. O exemplo a seguir usar essas opções.

+ +
var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };
+
+console.log(car.manyCars.b); // Jeep
+console.log(car[7]); // Mazda
+
+ +

Nomes de propriedades de objeto podem ser qualquer string, incluindo uma string vazia. Caso o nome da propriedade não seja um {{Glossary("Identifier","identificador")}} JavaScript ou número, ele deve ser colocado entre aspas. Nomes de propriedades que não possuem identificadores válido, também não podem ser acessadas pela propriedade de ponto (.), mas podem ser acessadas e definidas com a notação do tipo array ("[]").

+ +
var unusualPropertyNames = {
+  "": "Uma string vazia",
+  "!": "Bang!"
+}
+console.log(unusualPropertyNames."");   // SyntaxError: string inesperada
+console.log(unusualPropertyNames[""]);  // Um string vazia
+console.log(unusualPropertyNames.!);    // SyntaxError: símbolo ! inesperado
+console.log(unusualPropertyNames["!"]); // Bang!
+ +

Observe:

+ +
var foo = {a: "alpha", 2: "two"};
+console.log(foo.a);    // alpha
+console.log(foo[2]);   // two
+//console.log(foo.2);  // Error: missing ) after argument list
+//console.log(foo[a]); // Error: a não está definido
+console.log(foo["a"]); // alpha
+console.log(foo["2"]); // two
+
+ +

String Literal

+ +

Uma string literal são zero ou mais caracteres dispostos em aspas duplas (") ou aspas simples ('). Uma sequência de caracteres deve ser delimitada por aspas do mesmo tipo; ou seja,  as duas aspas simples ou ambas aspas duplas. A seguir um exemplo de strings literais.

+ +
"foo"
+'bar'
+"1234"
+"um linha \n outra linha"
+"John's cat"
+
+ +

Você pode chamar qualquer um dos métodos do objeto string em uma string literal - JavaScript automaticamente converte a string literal para um objeto string temporário, chama o método, em seguida, descarta o objeto string temporário. Você também pode usar a propriedade String.length com uma string literal:

+ +
console.log("John's cat".length)
+// Irá exibir a quantidade de caracteres na string incluindo o espaço em branco.
+// Nesse caso, 10 caracteres.
+
+ +

Você deve usar string literal, a não ser que você precise usar um objeto string. Veja {{jsxref("String")}} para detalhes sobre objetos de strings.

+ +

Uso de caracteres especiais em string

+ +

Além dos caracteres comuns, você também pode incluir caracteres especiais em strings, como mostrado no exemplo a seguir.

+ +
"uma linha \n outra linha"
+
+ +

A tabela a seguir lista os caracteres especiais que podem ser usados em strings no JavaScript.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Tabela: Caracteres especiais no JavaScript
CaracterDescrição
\0Byte nulo
\bBackspace
\fAlimentador de formulário
\nNova linha
\rRetorno do carro
\tTabulação
\vTabulação vertical
\'Apóstrofo ou aspas simples
\"Aspas dupla
\\Caractere de barra invertida
\XXX +

Caractere com a codificação Latin-1 especificada por três dígitos octal XXX entre 0 e 377. Por exemplo, \251 é sequência octal para o símbolo de direitos autorais.

+
\xXX +

Caractere com a codificação Latin-1 especificada por dois dígitos hexadecimal XX entre 00 e FF. Por exemplo, \xA9 é a sequência hexadecimal para o símbolo de direitos autorais.

+
\uXXXX +

Caractere Unicode especificado por quatro dígitos hexadecimal XXXX. Por exemplo, \u00A9 é a sequência Unicode para o símbolo de direitos autorais. Veja sequências de escape Unicode.

+
+ +

Caracteres de escape

+ +

Para caracteres não listados na tabela, se precedidos de barra invertida ela é ignorada, seu uso está absoleto e deve ser ignorado.

+ +

Você pode inserir uma aspa dentro de uma string precendendo-a com uma barra invertida. Isso  é conhecido como escaping das aspas. Por exemplo:

+ +
var quote = "Ele lê \"The Cremation of Sam McGee\" de R.W. Service.";
+console.log(quote);
+
+ +

O resultado disso seria:

+ +
Ele lê "The Cremation of Sam McGee" de R.W. Service.
+
+ +

Para incluir uma barra invertida dentro de uma string, você deve escapar o caractere de barra invertida. Por exemplo, para atribuir o caminho do arquivo c:\temp para uma string, utilize o seguinte:

+ +
var home = "c:\\temp";
+
+ +

Você também pode escapar quebras de linhas, precedendo-as com barra invertida. A barra invertida e a quebra de linha são ambas removidas da string.

+ +
var str = "esta string \
+está quebrada \
+em várias\
+linhas."
+console.log(str);   // esta string está quebrada em várias linhas.
+
+ +

Embora JavaScript não tenha sintaxe "heredoc", você pode adicionar uma quebra de linha e um escape de quebra de linha no final de cada linha:

+ +
var poem =
+"Rosas são vermelhas,\n\
+Violetas são azul.\n\
+Eu sou esquizofrênico,\n\
+e é isso que sou."
+
+ +

Mais informação

+ +

Este capítulo focou na sintaxe básica das declarações e tipos. Para saber mais sobre a linguagem JavaScript, veja também os seguintes capítulos deste guia:

+ + + +

No próximo capítulo, veremos a construção de controle de fluxos e manipulação de erro.

+ +

{{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Control_flow_and_error_handling")}}

diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/array/prototype/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/array/prototype/index.html new file mode 100644 index 0000000000..e863d9cc69 --- /dev/null +++ b/files/pt-br/orphaned/web/javascript/reference/global_objects/array/prototype/index.html @@ -0,0 +1,206 @@ +--- +title: Array.prototype +slug: Web/JavaScript/Reference/Global_Objects/Array/prototype +tags: + - Array + - JavaScript + - Propriedade +translation_of: Web/JavaScript/Reference/Global_Objects/Array/prototype +--- +
{{JSRef}}
+ +

Descrição

+ +

Instâncias de {{jsxref("Global_Objects/Array", "Array")}} herdam de Array.prototype. Como em todos os construtores, você pode mudar o  protótipo desse construtor para modificar todas as instâncias de {{jsxref("Global_Objects/Array", "Array")}}.

+ +

Contudo, a adição de métodos não-padronizados ao objeto array pode causar problemas futuros, seja com seu próprio código, ou na adição de novas funcionalidades ao JavaScript.

+ +

Um fato pouco conhecido: O próprio Array.prototype é um {{jsxref("Global_Objects/Array", "Array")}}

+ +
Array.isArray(Array.prototype); // true
+
+ +

Propriedades

+ +
+
Array.prototype.constructor
+
Especifica a função que cria um objeto do protótipo.
+  
+
{{jsxref("Array.prototype.length")}}
+
Reflete o número de elementos em um array.
+
+ +

Métodos

+ +

Métodos modificadores

+ +

Esses métodos modificam o array:

+ +
+
{{jsxref("Array.prototype.copyWithin()")}} {{experimental_inline}}
+
Copia uma sequência de elementos do array dentro do array.
+
{{jsxref("Array.prototype.fill()")}} {{experimental_inline}}
+
Preenche todos os elementos de um array com um elemento estático, começando de um índice inicial até um índice final.
+
{{jsxref("Array.prototype.pop()")}}
+
Remove e retorna o último elemento de um array.
+
{{jsxref("Array.prototype.push()")}}
+
Adiciona um ou mais elementos ao fim de um array e retorna o novo comprimeiro do array.
+
{{jsxref("Array.prototype.reverse()")}}
+
Reverte a ordem dos elementos de um array - o primeiro vira o último e o último vira o primeiro.
+
{{jsxref("Array.prototype.shift()")}}
+
Remove o primeiro elemento de um array e o retorna.
+
{{jsxref("Array.prototype.sort()")}}
+
Ordena os elementos do array em questão e retorna o array.
+
{{jsxref("Array.prototype.splice()")}}
+
Adiciona e/ou remove elementos de um array.
+
{{jsxref("Array.prototype.unshift()")}}
+
Adiciona um ou mais elementos ao início de um array e retorna o novo comprimento do array.
+
+ +

Métodos de acesso

+ +

Esses métodos não modificam o array, mas sim retornam alguma representação dele.

+ +
+
{{jsxref("Array.prototype.concat()")}}
+
Retorna um novo array formado por esse array concatenado com outro(s) array(s) e/ou valores.
+
{{jsxref("Array.prototype.contains()")}} {{experimental_inline}}
+
Verifica se o array possui cer, retornandotrue ou false apropriadamente.
+
{{jsxref("Array.prototype.join()")}}
+
Retorna uma string com todos os elementos do array
+
{{jsxref("Array.prototype.slice()")}}
+
Retorna um novo array com uma parte do array sobre o qual o método foi chamado
+
{{jsxref("Array.prototype.toSource()")}} {{non-standard_inline}}
+
Retorna um array literal representando o array especificado; você pode usar esse valor para criar um novo array. Esse método sobrescreve o método {{jsxref("Object.prototype.toSource()")}}.
+
{{jsxref("Array.prototype.toString()")}}
+
Retonar uma string representando o array e seus elementos. Esse método sobrescreve o método {{jsxref("Object.prototype.toString()")}}.
+
{{jsxref("Array.prototype.toLocaleString()")}}
+
Retonar uma string adequada ao idioma do usuário representando o array e seus elementos. Esse método sobrescreve o método {{jsxref("Object.prototype.toLocaleString()")}}.
+
{{jsxref("Array.prototype.indexOf()")}}
+
Representa o índice da primeira ocorrência de um valor especificado no array, ou -1 se o valor não estiver incluso no array.
+
{{jsxref("Array.prototype.lastIndexOf()")}}
+
Representa o índice da última ocorrência de um valor especificado no array, ou -1 se o valor não estiver incluso no array
+
+ +

Métodos de iteração

+ +

Vários métodos tomam como funções de argumento para serem chamados de volta ao processar o array. Quando esses métodos são chamados, o `length` do array é amostrado e qualquer elemento adicionado além deste comprimento (length)  de dentro da função (callback) não é visitado. Outras alterações para o array (Definindo o valor de ou apagando um elemento) pode afetar os resultados da operação se o método visita o elemento alterado posteriormente. Enquanto o comportamento específico destes métodos nestes casos é bem definido, não se deve confiar nisso para não confundir os outros que possoam ler seu código. Em vez disso, deve-se copiar para um novo array para modificá-lo.

+ +
+
{{jsxref("Array.prototype.forEach()")}}
+
Chama a função para cada elemento no array.
+
{{jsxref("Array.prototype.entries()")}} {{experimental_inline}}
+
Retorna um novo objeto Array Iterator que contem o par chave/valor para cada índice no array.
+
{{jsxref("Array.prototype.every()")}}
+
Retorna true se todos elementos no array satisfizer a função de teste fornecida.
+
{{jsxref("Array.prototype.some()")}}
+
Retorna true se pelo menos um elemento no array satisfizer a função de teste fornecida.
+
{{jsxref("Array.prototype.filter()")}}
+
Cria um novo array com todos os elementos do array para qual a função de filtragem fornecida retorne true.
+
{{jsxref("Array.prototype.find()")}} {{experimental_inline}}
+
Retorna o valor encontrado no array, se um elemento no array satisfizer a funçào de teste fornecida ou  `undefined` se não for encontrado.
+
{{jsxref("Array.prototype.findIndex()")}} {{experimental_inline}}
+
Retorna o índice no array, se um elemento no array satisfizer a função de teste fornecida ou -1 se não for encontrado.
+
{{jsxref("Array.prototype.keys()")}} {{experimental_inline}}
+
Retorna um novo Array Iterator que contem a chave para cada índice no array.
+
{{jsxref("Array.prototype.map()")}}
+
Cria um novo array com os resultados da função fornecida chamada em cada elemento na array.
+
{{jsxref("Array.prototype.reduce()")}}
+
Aplica uma função contra um acumulador e cada valor do array (da esquerda para direita) para reduzi-los a um único valor.
+
{{jsxref("Array.prototype.reduceRight()")}}
+
Aplica uma função contra um acumulador e cada valor do array (da direita para esquerda) para reduzi-los a um único valor.
+
{{jsxref("Array.prototype.values()")}} {{experimental_inline}}
+
Retorna um novo objeto Array Iterator que contem os valores de cada índice no array.
+
{{jsxref("Array.prototype.@@iterator()", "Array.prototype[@@iterator]()")}} {{experimental_inline}}
+
Retorna um novo objeto Array Iterator que contem os valores de cada índice no array.
+
+ +

Métodos genéricos

+ +

Vários métodos do objeto Array em Javascript foram feitos para serem aplicados genericamentes em todos os objetos que "pareçam" Arrays. Isso é, eles podem ser usados em qualquer objeto que possuam uma propriedade length (comprimento), e que possa ser usado a partir de propriedades numéricas (como índices no formato array[5]). Alguns métodos, como {{jsxref("Array.join", "join")}}, apenas lêem e as propriedades numéricas do objeto sobre o qual eles sãochamados. Outros, como {{jsxref("Array.reverse", "reverse")}}, exigem que as propriedades numéricas e length sejam mutáveis; sendo assim, esses métodos não podem ser chamados em objetos como {{jsxref("Global_Objects/String", "String")}}, que não permitem que nenhuma das duas propriedades sejam modificadas.

+ +

Especifiações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoSituaçãoComentário
ECMAScript 1st Edition.PadrãoDefinição inicial
{{SpecName('ES5.1', '#sec-15.4.3.1', 'Array.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-array.prototype', 'Array.prototype')}}{{Spec2('ES6')}} 
+ +

Compatibilidade com Navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/bigint/prototype/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/bigint/prototype/index.html new file mode 100644 index 0000000000..ff8de05541 --- /dev/null +++ b/files/pt-br/orphaned/web/javascript/reference/global_objects/bigint/prototype/index.html @@ -0,0 +1,61 @@ +--- +title: BigInt.prototype +slug: Web/JavaScript/Reference/Global_Objects/BigInt/prototype +tags: + - BigInt + - JavaScript + - Propriedade + - Prototipo + - Referencia +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/prototype +--- +
{{JSRef}}
+ +

A propriedade BigInt.prototype representa o protótipo para o  construtor {{JSxRef("BigInt")}} .

+ +

{{JS_Property_Attributes(0, 0, 0)}}

+ +

Descrição

+ +

Todas instância de {{JSxRef("BigInt")}} herdam de BigInt.prototype. O objeto protótipo do construtor {{JSxRef("BigInt")}} pode ser modificado para afetar todas instâncias de {{JSxRef( "BigInt")}} .

+ +

Propriedades

+ +
+
BigInt.prototype.constructor
+
Retorna a função que cria instâncias deste objeto. Por padrão é o objeto
+ {{JSxRef("BigInt")}}.
+
+ +

Métodos

+ +
+
{{JSxRef("BigInt.prototype.toLocaleString()")}}
+
Retorna uma string com uma representação sensível ao idioma para este número. Sobrescreve o método {{JSxRef("Object.prototype.toLocaleString()")}}
+  
+
{{JSxRef("BigInt.prototype.toString()")}}
+
Retorna uma string respresentando o objeto específicado em um base específica. Sobrescreve o método {{JSxRef("Object.prototype.toString()")}} .
+
{{JSxRef("BigInt.prototype.valueOf()")}}
+
Retorna o valor primitivo de um objeto específicado. Sobrescreve o método {{JSxRef("Object.prototype.valueOf()")}}.
+
+ +

Especificações

+ + + + + + + + + + + + +
EspecificaçõesEstado
{{SpecName('ESDraft', '#sec-bigint.prototype', 'BigInt.prototype')}}{{Spec2('ESDraft')}}
+ +

Compatibilidade

+ + + +

{{Compat("javascript.builtins.BigInt.prototype")}}

diff --git a/files/pt-br/orphaned/web/security/information_security_basics/index.html b/files/pt-br/orphaned/web/security/information_security_basics/index.html new file mode 100644 index 0000000000..9508b0afdb --- /dev/null +++ b/files/pt-br/orphaned/web/security/information_security_basics/index.html @@ -0,0 +1,32 @@ +--- +title: Básico de Segurança da Informação +slug: Web/Security/Básico_de_Segurança_da_Informação +tags: + - Iniciante + - Segurança +translation_of: Web/Security/Information_Security_Basics +--- +

Entender o básico de segurança da informação pode ajudar você a evitar que seu software ou website estejam inseguros e vulneráveis a fraquezas que podem ser exploradas para ganhos financeiros ou outros motivos maliciosos. Estes artigos podem ajudar você a aprender o que você precisa. Com essa informação, você estará ciente do papel e importância da segurança no ciclo de desenvolvimento de software, além da distribuição do seu conteúdo.

+ +

Confidencialidade, Integridade e Disponibilidade

+ +
+
Descreve os objetivos de segurança primários, que são absolutamente fundamentais para o entendimento de segurança
+
Vulnerabilidades
+
Define as principais categorias de vulnerabilidades e discute a presença de vulnerabilidades em todo software
+
Ameaças
+
Introduz brevemente os principais conceitos de ameaças
+
Controles de Segurança
+
Define as principais categorias de controle de segurança e discute suas potenciais desvantagens
+
Segurança TCP/IP
+
Uma visão geral do modelo TCP/IP, com um foco em considerações de segurança para SSL
+
+ +

Veja também

+ + -- cgit v1.2.3-54-g00ecf