Artigos e códigos foram arquivados em [Github warehouse: https://github.com/timerring/backend-tutorial ] ou a conta pública [AIShareLab] também pode ser obtida respondendo a go .
Diretório de artigos
- Introdução
- Introdução ao Go
-
- ir instalação
- Go ambiente de desenvolvimento
- gramática básica
- variável
- if-else
- ciclo
- trocar
- variedade
- fatiar
- mapa
- faixa
- função
- ponteiro
- estrutura
- Método struct
- Manipulação de erros
- manipulação de string
- formatação de string
- Processamento JSON
- processamento de tempo
- análise digital
- processo de informação
Introdução
Qual é a linguagem Go
- Alto desempenho e alta simultaneidade
- Sintaxe simples e curva de aprendizado suave
- Biblioteca padrão rica (em muitos casos, o desenvolvimento de funções básicas pode ser concluído sem a ajuda de bibliotecas de terceiros)
- Cadeia de ferramentas perfeita (seja compilação, inspeção de código, prompts suplementares etc., existem ferramentas correspondentes e uma estrutura completa de teste de unidade, teste de desempenho etc.)
- Vinculação estática (todos os resultados da compilação são vinculados estaticamente, você só precisa copiar o arquivo executável compilado, pode executá-lo diretamente sem adicionar nada, a implantação é conveniente e rápida. Comparado com o java, ele precisa de um enorme jre para ser executado)
- compilação muito rápida
- Plataforma cruzada (pode ser executado em vários dispositivos e possui recursos de compilação cruzada, sem necessidade de configurar um ambiente de compilação cruzada)
- Coleta de lixo (foco na lógica de negócios, sem necessidade de considerar alocação e liberação de memória)
Quais empresas usam a linguagem Go
Em primeiro lugar, a ByteDance adotou totalmente a linguagem go. Existem dezenas de milhares de microsserviços na empresa escritos em golang. Não muito tempo atrás, o framework GORPC KiteX também era de código aberto. Tencent, Baidu, Meituan, Didi, Sangfor, Ping An, OPPO, Zhihu, Qunar, 360, Jinshan, Weibo, bilibili, Qiniu, PingCAP e outras empresas também usam a linguagem Go extensivamente.
Empresas estrangeiras como Google e Facebook também estão usando a linguagem Go extensivamente.
Do ponto de vista dos negócios, a linguagem tem florescido em computação em nuvem, microsserviços, big data, blockchain, Internet das Coisas e outros campos. Então, nas áreas de computação em nuvem e microsserviços,
Docker, Kubernetes, Istio, etcd e prometheus já têm uma participação de mercado muito alta. Quase todos os componentes nativos da nuvem são implementados em Go.
Por que transformar a linguagem Go
- No início, o negócio de back-end da empresa era principalmente back-end da Web. A equipe inicial não tinha experiência em Java e C++ não era adequado para negócios on-line na Web.
- O serviço inicial era o python. Desde 2014, com o crescimento do volume de negócios, o python encontrou alguns problemas de desempenho.
- Algumas equipes inicialmente tentaram usar o Go e descobriram que começar é fácil, a eficiência do desenvolvimento é alta e o desempenho é relativamente bom.
- O desenvolvimento e a implantação da linguagem Go são muito simples e, a propósito, resolve o problemático problema de versão da biblioteca de dependência causado pelo python antes.
- —Depois que algumas empresas experimentaram a doçura, começaram a promovê-la vigorosamente no nível da empresa, e as estruturas internas de rpc e http baseadas em golang da empresa nasceram.
Introdução ao Go
ir instalação
Visite go.dev/ ou visite studygolang.com/dl
Go ambiente de desenvolvimento
- Ambiente de desenvolvimento baseado em nuvem: ambiente de programação on-line gitpods.IO, requer conta GitHub
- Ambiente de desenvolvimento integrado: Vs Code (gratuito) ou Goland (pago)
gramática básica
// package main 代表这个文件属于main包的一部分, main包也就是程序的入口包。
package main
// 导入了标准库里面的 FMT 包。这个包主要是用来往屏幕输入输出字符串、格式化字符串。
import (
"fmt"
)
// import 下面是 main 函数，main 函数的话里面调用了 fmt.Println 输出 helloworld要运行这个程序的话，我们就直接 go run heloworld.go。
func main() {
fmt.Println("hello world")
}
Se você quiser compilá-lo em binário, você pode go buildcompilá-lo em . Após a conclusão da compilação, ./hellowordvocê pode executá-lo diretamente em FMT. Existem muitas funções no pacote para fazer diferentes tarefas de formatação de entrada e saída. Você pode passar o mouse sobre seu código no editor para ver a documentação de cada função.
Você também pode inserir pkg.Go.Dev, adicionar o nome do seu pacote, como FMT, e então você pode ver a documentação online deste pacote, a partir da qual você pode selecionar as funções que você precisa usar.
variável
package main
import (
"fmt"
"math"
)
func main() {
var a = "initial"
var b, c int = 1, 2
var d = true
var e float64
f := float32(e)
g := a + "foo"
fmt.Println(a, b, c, d, e, f) // initial 1 2 true 0 0
fmt.Println(g) // initialapple
const s string = "constant"
const h = 500000000
const i = 3e20 / h
fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
}
Vejamos o segundo exemplo, sobre tipos de variáveis.
A linguagem go é uma linguagem fortemente tipada e cada variável tem seu próprio tipo de variável. Tipos de variáveis comuns incluem strings, inteiros, tipos de ponto flutuante, tipos booleanos, etc. Strings na linguagem go são tipos integrados, que podem ser concatenados diretamente com um sinal de mais ou usados diretamente para comparar duas strings com um sinal de igual .
Declaração de variáveis na linguagem go, existem duas formas de declarar variáveis na linguagem go
- Uma delas é
var name string=" "declarar variáveis desta forma.Ao declarar uma variável, o tipo da variável é geralmente deduzido automaticamente. Se necessário, o tipo de variável também pode ser escrito explicitamente. - Outra maneira de declarar variáveis é usar
变量 := 等于值.
Para constantes, troque var por const. O valor mencionado é uma constante na linguagem go. Não tem tipo definido, e o tipo será determinado automaticamente de acordo com o contexto de uso.
if-else
package main
import "fmt"
func main() {
if 7%2 == 0 {
fmt.Println("7 is even")
} else {
fmt.Println("7 is odd")
}
if 8%4 == 0 {
fmt.Println("8 is divisible by 4")
}
if num := 9; num < 0 {
fmt.Println(num, "is negative")
} else if num < 10 {
fmt.Println(num, "has 1 digit")
} else {
fmt.Println(num, "has multiple digits")
}
}
O método de escrita do if else na linguagem Go é semelhante ao C ou C++. A diferença é que não há parênteses depois de if, e if em Golang, deve ser seguido por chaves, e você não pode colocar as instruções diretamente em if na mesma linha como C ou C++.
ciclo
package main
import "fmt"
func main() {
i := 1
for {
fmt.Println("loop")
break
}
for j := 7; j < 9; j++ {
fmt.Println(j)
}
for n := 0; n < 5; n++ {
if n%2 == 0 {
continue
}
fmt.Println(n)
}
for i <= 3 {
fmt.Println(i)
i = i + 1
}
}
Não há loops while e loops do while em go, mas apenas um tipo de loop for. O loop for mais simples é não escrever nada depois de for, o que significa um loop infinito. Você pode usar break ou continue para sair ou continuar o loop.
trocar
package main
import (
"fmt"
"time"
)
func main() {
a := 2
switch a {
case 1:
fmt.Println("one")
case 2:
fmt.Println("two")
case 3:
fmt.Println("three")
case 4, 5:
fmt.Println("four or five")
default:
fmt.Println("other")
}
t := time.Now()
switch {
// case 里面写条件分支
case t.Hour() < 12:
fmt.Println("It's before noon")
default:
fmt.Println("It's after noon")
}
}
O nome da variável por trás do switch não requer parênteses. Há uma grande diferença aqui. Em C++, se o switch case não exibir uma quebra, ele continuará a ser executado em todos os casos. Na linguagem go, não há necessidade de adicionar uma quebra.
Comparado com C ou C++, a função switch na linguagem go é mais poderosa. Tipos de variáveis arbitrárias podem ser usados e até mesmo para substituir declarações if else arbitrárias. Você não pode adicionar nenhuma variável por trás do switch e, em seguida, escrever ramificações condicionais no caso. Dessa forma, a lógica do código será mais clara do que se você usar vários códigos if else.
variedade
package main
import "fmt"
func main() {
// 这里的话是一个可以存放 5 个 int 元素的数组 A
var a [5]int
a[4] = 100
fmt.Println("get:", a[2])
fmt.Println("len:", len(a))
b := [5]int{
1, 2, 3, 4, 5}
fmt.Println(b)
var twoD [2][3]int
for i := 0; i < 2; i++ {
for j := 0; j < 3; j++ {
twoD[i][j] = i + j
}
}
fmt.Println("2d: ", twoD)
}
Uma matriz é uma sequência numerada de elementos de comprimento fixo. Para uma matriz, é muito conveniente obter o valor de um índice específico ou armazenar um valor em um índice específico e imprimir diretamente uma matriz. No entanto, no código comercial real, raramente usamos matrizes diretamente, porque seu comprimento é fixo e usamos mais fatias.
fatiar
package main
import "fmt"
func main() {
s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"
fmt.Println("get:", s[2]) // c
fmt.Println("len:", len(s)) // 3
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println(s) // [a b c d e f]
c := make([]string, len(s))
copy(c, s)
fmt.Println(c) // [a b c d e f]
fmt.Println(s[2:5]) // [c d e]
fmt.Println(s[:5]) // [a b c d e]
fmt.Println(s[2:]) // [c d e f]
good := []string{
"g", "o", "o", "d"}
fmt.Println(good) // [g o o d]
}
Ao contrário das matrizes, as fatias podem alterar seu comprimento arbitrariamente e ter mais operações. Você pode usar make para criar uma fatia, pode obter valores como um array e usar append para adicionar elementos.
Preste atenção ao uso de append, você deve atribuir o resultado de append ao array original.
Como o princípio da fatia é na verdade ter um comprimento e uma capacidade, além de um ponteiro para uma matriz, quando você executa a operação de acréscimo, se a capacidade não for suficiente, ela se expandirá e retornará uma nova fatia.
O Slice também pode especificar o comprimento quando é inicializado.
Slice tem a mesma operação de fatiamento que o python, por exemplo, isso significa retirar os elementos da segunda à quinta posição, excluindo o quinto elemento. Mas, ao contrário do python, os índices negativos não são suportados aqui .
mapa
package main
import "fmt"
func main() {
// 用 make 来创建一个空 map，这里会需要两个类型。
// 第一个是那个 key 的类型，这里是 string 另一个是 value 的类型，这里是 int。
m := make(map[string]int)
// 可以从里面去存储或者取出键值对。
m["one"] = 1
m["two"] = 2
fmt.Println(m) // map[one:1 two:2]
fmt.Println(len(m)) // 2
fmt.Println(m["one"]) // 1
fmt.Println(m["unknow"]) // 0
r, ok := m["unknow"]
fmt.Println(r, ok) // 0 false
// 可以用 delete 从里面删除键值对。
delete(m, "one")
m2 := map[string]int{
"one": 1, "two": 2}
var m3 = map[string]int{
"one": 1, "two": 2}
fmt.Println(m2, m3)
}
Map é a estrutura de dados usada com mais frequência em uso real.
O mapa de Golang é completamente desordenado. Ao percorrer, não será em ordem alfabética, nem será gerado na ordem de inserção, mas em ordem aleatória.
faixa
package main
import "fmt"
func main() {
nums := []int{
2, 3, 4}
sum := 0
for i, num := range nums {
sum += num
if num == 2 {
fmt.Println("index:", i, "num:", num) // index: 0 num: 2
}
}
fmt.Println(sum) // 9
m := map[string]string{
"a": "A", "b": "B"}
for k, v := range m {
fmt.Println(k, v) // b 8; a A
}
for k := range m {
fmt.Println("key", k) // key a; key b
}
}
Para uma fatia ou um mapa, podemos usar o intervalo para percorrer rapidamente, para que o código seja mais conciso. Quando Range atravessa, dois valores são retornados para o array, o primeiro é o índice e o segundo é o valor da posição correspondente. Se não precisarmos de um índice, podemos omiti-lo com um sublinhado.
função
package main
import "fmt"
func add(a int, b int) int {
return a + b
}
func add2(a, b int) int {
return a + b
}
func exists(m map[string]string, k string) (v string, ok bool) {
v, ok = m[k]
return v, ok
}
func main() {
res := add(1, 2)
fmt.Println(res) // 3
// 第一个是真正的返回结果，第二个值是一个错误信息
v, ok := exists(map[string]string{
"a": "A"}, "a")
fmt.Println(v, ok) // A True
}
Esta é uma função simples em Golang para adicionar duas variáveis. A diferença entre Golang e muitos outros idiomas é que o tipo de variável é pós-fixado.
As funções em Golang oferecem suporte nativo ao retorno de vários valores. No código de lógica de negócios real, quase todas as funções retornam dois valores, o primeiro é o resultado de retorno real e o segundo valor é uma mensagem de erro.
ponteiro
package main
import "fmt"
func add2(n int) {
n += 2
}
func add2ptr(n *int) {
*n += 2
}
func main() {
n := 5
add2(n)
fmt.Println(n) // 5
add2ptr(&n)
fmt.Println(n) // 7
}
Ponteiros também são suportados em Go. Obviamente, em comparação com ponteiros em C e C++, as operações suportadas são muito limitadas. Um dos principais usos dos ponteiros é modificar os parâmetros de entrada.
Por exemplo, a função acima tenta adicionar 2 a uma variável. Mas simplesmente escrever como o acima é realmente inválido. Como o parâmetro passado para a função é na verdade um shell, também é dito que esse +2 é +2 para a cópia e não funciona. Se precisarmos trabalhar, precisamos escrever esse tipo como um tipo de ponteiro e, para correspondência de tipo, um símbolo & será adicionado ao chamar.
estrutura
package main
import "fmt"
type user struct {
name string
password string
}
func main() {
a := user{
name: "wang", password: "1024"}
b := user{
"wang", "1024"}
c := user{
name: "wang"}
c.password = "1024"
var d user
d.name = "wang"
d.password = "1024"
fmt.Println(a, b, c, d) // {wang 1024} {wang 1024} {wang 1024} {wang 1024}
fmt.Println(checkPassword(a, "haha")) // false
fmt.Println(checkPassword2(&a, "haha")) // false
}
func checkPassword(u user, password string) bool {
return u.password == password
}
// 同样的结构体我们也能支持指针，这样能够实现对于结构体的修改，也可以在某些情况下避免一些大结构体的拷贝开销。
func checkPassword2(u *user, password string) bool {
return u.password == password
}
Uma estrutura é uma coleção de campos digitados.
Por exemplo, a estrutura do usuário contém dois campos, nome e senha. Podemos usar o nome da estrutura para inicializar uma variável de estrutura, ao construir precisamos passar o valor inicial de cada campo. Você também pode usar esse par chave-valor para especificar o valor inicial, para que apenas uma parte dos campos possa ser inicializada.
Método struct
package main
import "fmt"
type user struct {
name string
password string
}
func (u user) checkPassword(password string) bool {
return u.password == password
}
func (u *user) resetPassword(password string) {
u.password = password
}
func main() {
a := user{
name: "wang", password: "1024"}
a.resetPassword("2048")
fmt.Println(a.checkPassword("2048")) // true
}
Em Golang, alguns métodos podem ser definidos para a estrutura. Será um pouco semelhante às funções de membro de classe em outros idiomas. Por exemplo, aqui, mudamos checkPassworda implementação do exemplo acima de uma função comum para um método de estrutura. Desta forma, o usuário pode chamá-lo como a.checkPassword ("x") D A modificação específica do código é adicionar o primeiro parâmetro, adicionar parênteses e escrevê-lo na frente do nome da função.
Existem também duas formas de escrever ao implementar o método da estrutura, uma é com ponteiro e a outra é sem ponteiro. Se você tiver um ponteiro, poderá modificar essa estrutura. Se não houver ponteiro, a operação é na verdade uma cópia e você não pode modificar a estrutura.
Manipulação de erros
package main
import (
"errors"
"fmt"
)
type user struct {
name string
password string
}
// 在函数里面，我们可以在那个函数的返回值类型里面，后面加一个 error，就代表这个函数可能会返回错误。
func findUser(users []user, name string) (v *user, err error) {
for _, u := range users {
if u.name == name {
return &u, nil
}
}
return nil, errors.New("not found")
}
func main() {
u, err := findUser([]user{
{
"wang", "1024"}}, "wang")
if err != nil {
fmt.Println(err)
return
}
fmt.Println(u.name) // wang
if u, err := findUser([]user{
{
"wang", "1024"}}, "li"); err != nil {
fmt.Println(err) // not found
return
} else {
fmt.Println(u.name)
}
}
O tratamento de erros na linguagem go está de acordo com a abordagem idiomática de usar um valor de retorno separado para transmitir informações de erro.
É diferente das exceções usadas pelo próprio Java. O método de processamento da linguagem Go pode saber claramente qual função retorna um erro e pode usar um if else simples para lidar com o erro.
Em uma função, podemos adicionar um erro ao tipo de valor de retorno dessa função, o que significa que a função pode retornar um erro.
Então, quando a função for implementada, return precisa retornar dois valores ao mesmo tempo ou, se ocorrer um erro, pode ser return nilcombinado com um error. Caso contrário, retorne o resultado original e nil.
manipulação de string
package main
import (
"fmt"
"strings"
)
func main() {
a := "hello"
fmt.Println(strings.Contains(a, "ll")) // true
fmt.Println(strings.Count(a, "l")) // 2
fmt.Println(strings.HasPrefix(a, "he")) // true
fmt.Println(strings.HasSuffix(a, "llo")) // true
fmt.Println(strings.Index(a, "ll")) // 2
fmt.Println(strings.Join([]string{
"he", "llo"}, "-")) // he-llo
fmt.Println(strings.Repeat(a, 2)) // hellohello
fmt.Println(strings.Replace(a, "e", "E", -1)) // hEllo
fmt.Println(strings.Split("a-b-c", "-")) // [a b c]
fmt.Println(strings.ToLower(a)) // hello
fmt.Println(strings.ToUpper(a)) // HELLO
fmt.Println(len(a)) // 5
b := "你好"
fmt.Println(len(b)) // 6
}
Existem muitas funções de ferramenta de string comumente usadas no pacote de strings da biblioteca padrão, como contains para determinar se uma string contém outra string, contagem para contagem de strings e índice para encontrar a posição de uma determinada string. Join junta várias strings repete repete várias strings substitui substitui strings.
formatação de string
package main
import "fmt"
type point struct {
x, y int
}
func main() {
s := "hello"
n := 123
p := point{
1, 2}
fmt.Println(s, n) // hello 123
fmt.Println(p) // {1 2}
fmt.Printf("s=%v\n", s) // s=hello
fmt.Printf("n=%v\n", n) // n=123
fmt.Printf("p=%v\n", p) // p={1 2}
fmt.Printf("p=%+v\n", p) // p={x:1 y:2}
fmt.Printf("p=%#v\n", p) // p=main.point{x:1, y:2}
f := 3.141592653
fmt.Println(f) // 3.141592653
fmt.Printf("%.2f\n", f) // 3.14
}
Na linguagem go, você pode usá-la facilmente %vpara imprimir qualquer tipo de variável sem distinguir entre strings numéricas. Você também pode %+vimprimir resultados detalhados com , %#vque é mais detalhado.
Processamento JSON
package main
import (
"encoding/json"
"fmt"
)
type userInfo struct {
Name string
Age int `json:"age"`
Hobby []string
}
func main() {
a := userInfo{
Name: "wang", Age: 18, Hobby: []string{
"Golang", "TypeScript"}}
buf, err := json.Marshal(a)
if err != nil {
panic(err)
}
fmt.Println(buf) // [123 34 78 97...]
fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}
buf, err = json.MarshalIndent(a, "", "\t")
if err != nil {
panic(err)
}
fmt.Println(string(buf))
var b userInfo
err = json.Unmarshal(buf, &b)
if err != nil {
panic(err)
}
fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
}
A operação do JSON na linguagem go é muito simples, para uma estrutura existente não podemos fazer nada, desde que a primeira letra de cada campo seja maiúscula, ou seja, é um campo público. Em seguida, essa estrutura pode ser desserializada com JSON.Marshaler e transformada em uma string JSON.
A string serializada também pode ser desserializada em uma variável vazia com JSON.Unmarshaler.
Se a string for serializada por padrão dessa maneira, seu estilo começará com uma letra maiúscula em vez de um sublinhado. Podemos usar sintaxe como tag json para modificar o nome do campo no resultado JSON de saída posteriormente.
processamento de tempo
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
fmt.Println(now) // 2022-03-27 18:04:59.433297 +0800 CST m=+0.000087933
t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)
fmt.Println(t) // 2022-03-27 01:25:36 +0000 UTC
fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute()) // 2022 March 27 1 25
fmt.Println(t.Format("2006-01-02 15:04:05")) // 2022-03-27 01:25:36
diff := t2.Sub(t)
fmt.Println(diff) // 1h5m0s
fmt.Println(diff.Minutes(), diff.Seconds()) // 65 3900
t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")
if err != nil {
panic(err)
}
fmt.Println(t3 == t) // true
fmt.Println(now.Unix()) // 1648738080
}
O seguinte é o processamento de tempo. O mais comumente usado na linguagem go é time.Now ()obter a hora atual, e então você também pode usar time.Datepara construir uma hora com um fuso horário e a hora construída. Existem muitos métodos acima para obter o ano, mês, dia, hora, minuto e segundo neste momento e, em seguida, você também pode usar sub para subtrair os dois tempos para obter um período de tempo. No período de tempo, você pode obter quantas horas, quantos minutos e quantos segundos ele tem.
Ao interagir com determinados sistemas, geralmente usamos timestamps. Então você pode usar .UNIX()para obter o timestamp. time.format, time.parseusado para analisar o tempo, consulte a documentação para obter detalhes.
análise digital
package main
import (
"fmt"
"strconv"
)
func main() {
f, _ := strconv.ParseFloat("1.234", 64)
fmt.Println(f) // 1.234
n, _ := strconv.ParseInt("111", 10, 64)
fmt.Println(n) // 111
n, _ = strconv.ParseInt("0x1000", 0, 64)
fmt.Println(n) // 4096
n2, _ := strconv.Atoi("123")
fmt.Println(n2) // 123
n2, err := strconv.Atoi("AAA")
fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax
}
Vamos aprender como converter entre strings e números. Na linguagem go, todas as conversões entre strings e números estão neste strconvpacote, que é a abreviação das duas palavras string convert.
Podemos usar parselnt ou parseFloat para analisar uma string. Parâmetro Parseint
Podemos usar Atoi para converter uma string decimal em um número. Você pode usar itoA para converter números em strings. Se a entrada for inválida, essas funções retornarão um erro.
processo de informação
package main
import (
"fmt"
"os"
"os/exec"
)
func main() {
// 比如我们编译的一个二进制文件，command。后面接 abcd 来启动，输出就是os.argv会是一个长度为5的 slice ,第一个成员代表:进制自身的名字。
// go run example/20-env/main.go a b c d
fmt.Println(os.Args) // [/var/folders/8p/n34xxfnx38dg8bv_x8l62t_m0000gn/T/go-build3406981276/b001/exe/main a b c d]
fmt.Println(os.Getenv("PATH")) // /usr/local/go/bin...
fmt.Println(os.Setenv("AA", "BB"))
buf, err := exec.Command("grep", "127.0.0.1", "/etc/hosts").CombinedOutput()
if err != nil {
panic(err)
}
fmt.Println(string(buf)) // 127.0.0.1 localhost
}
Em go, podemos os.argvusá para obter os parâmetros de linha de comando especificados quando o programa é executado.
Podemos os.getenvusá ler variáveis de ambiente.