Ruby 3

Blocos e iteradores em Ruby

As duas sintaxes para criar um bloco de código:

{ puts "Alô, Mundo!" } # note as chaves

# ou:
do
  puts "Alô, Mundo!"
end

Um bloco de código pode ser passado a um método com um argumento opcional do bloco. Várias métodos internos possuem tais argumentos:

File.open('file.txt', 'w') do |file|       # 'w' denota "modo de escrita"
  file.puts 'Wrote some text.'
end                                  # o arquivo é automaticamente fechado aqui
 
File.readlines('file.txt').each do |line|
  puts line
end
# => Escreveu algum texto.

Passagem de um parâmetro de um bloco com fechamento:

(também fechamento lexical ou fechamento de função) é uma função ou referência a uma função, juntamente com um ambiente de referência. Um fechamento, ao contrário de uma função simples ponteiro permite que uma função possa acessar essas variáveis ​​não-locais, mesmo quando chamado fora de seu escopo lexical imediato.

# In an object instance variable (denoted with '@'), remember a block.
def remember(&a_block)
  @block = a_block
end
 
# Invoke the preceding method, giving it a block which takes a name.
remember {|name| puts "Hello, #{name}!"}
 
# Call the closure:
@block.call("Jon")   # => "Hello, Jon!"

Criado uma função anônima:

proc {|arg| puts arg}
Proc.new {|arg| puts arg}
lambda {|arg| puts arg}
->(arg) {puts arg}         # introduced in Ruby 1.9

Retornando o fechamento de um método:

def create_set_and_get(initial_value=0) # note the default value of 0
  closure_value = initial_value
  return Proc.new {|x| closure_value = x}, Proc.new { closure_value }
end
 
setter, getter = create_set_and_get  # returns two values
setter.call(21)
getter.call      # => 21
 
# Parameter variables can also be used as a binding for the closure,
# so the preceding can be rewritten as:
 
def create_set_and_get(closure_value=0)
  return proc {|x| closure_value = x } , proc { closure_value }
end

Cedendo o fluxo de controle do programa para um bloco que foi fornecido no momento da chamada:

def use_hello
  yield "hello"
end
 
# Invoke the preceding method, passing it a block.
use_hello {|string| puts string}  # => 'hello'

Iterações sobre enumerações e arrays utilizando blocos:

array = [1, 'hi', 3.14]
array.each {|item| puts item }
# prints:
# 1
# 'hi'
# 3.14
 
array.each_index {|index| puts "#{index}: #{array[index]}" }
# prints:
# 0: 1
# 1: 'hi'
# 2: 3.14
 
# The following uses a Range
(3..6).each {|num| puts num }
# prints:
# 3
# 4
# 5
# 6

Um método como inject pode aceitar ambos, um parâmetro e um bloco. Ele faz iteração sobre cada membro da list, executa algumas funções nele enquanto mantem um agregado.

[1,3,5].inject(10) {|sum, element| sum + element}   # => 19

Na primeira passagem, o bloco recebe 10 (o argumento para inject) como soma, e um (o primeiro elemento da array) como element. Isso retorna 11, que torna-se então soma na próxima passagem. Ele é adicionado a 3 para obter 14, que é então adicionada a 5 no terceiro passo, para finalmente voltar 19.

Usando uma enumeração e um bloco ao quadrado os números de 1 a 10 (com um intervalo):

(1..10).collect {|x| x*x}  # => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Ou invoca um método a cada item (map é um sinônimo para collect):

(1..5).map(&:to_f)  # => [1.0, 2.0, 3.0, 4.0, 5.0]

Função anônima (também função constante, função literal ou função lambda) é uma função (ou uma sub-rotina) definida, e possivelmente chamada, sem estar vinculado a um identificador. 

Funções anônimas são convenientes para passar como um argumento para uma função de ordem superior e são onipresentes em línguas com funções de primeira classe. 

É uma forma de função aninhada, na medida em que permitem o acesso a variáveis ​​no escopo da função que contém (variáveis ​​não- locais). Ao contrário das funções aninhadas nomeadas, elas não podem ser recursiva sem a assistência de um operador fixpoint ( também conhecido como um fixpoint anônimo ou recursão anônimo) .

Ruby 2

Ruby

Sintaxe do Ruby

• A sintaxe de Ruby é muito semelhante ao de Perl e Python. 
• As definições de classe e método são sinalizadas por palavras-chave. Em contraste com Perl, variáveis ​​não são obrigatoriamente prefixada com um sigil ($, etc). Quando utilizado, o sigil muda a semântica do escopo da variável.
• Uma diferença de C e Perl é que as palavras-chave são normalmente usados ​​para definir blocos de código lógicas, sem chaves (ou seja , um par de { e } ).
• Para fins práticos, não há distinção entre as expressões e declarações.
• As quebras de linha são significativas e tomado como o fim de uma instrução; um ponto e vírgula podem ser usados ​​de forma equivalente.
• Ao contrário de Python , o recuo não é significativo.
• Uma das diferenças do Ruby em comparação com Python e Perl é que o Ruby mantém todas as suas variáveis ​​de instância completamente privadas para a classe e só as expõe através de métodos de acesso ( attr_writer, attr_reader , etc.).
• Ao contrário dos " getter " e " setter " métodos de outras linguagens como C++ ou Java, métodos de acesso em Ruby pode ser criado com uma única linha de código via metaprogramação, no entanto, métodos de acesso também pode ser criada na forma tradicional de C++ e Java.
• Como invocação desses métodos não requer o uso de parênteses, é trivial para mudar uma variável de instância em uma função cheia, sem modificar uma única linha de código ou ter que fazer qualquer refatoração para alcançar as funcionalidade semelhante aos membros de propriedade do C# e VB.NET. 
• Descritores de propriedade do Python são semelhantes, mas vêm com uma trade-off(perde-ganha) no processo de desenvolvimento.
• Se alguém começa em Python usando uma variável de instância exposto publicamente, e mais tarde muda a implementação para usar uma variável de instância privada exposta através de um descritor de propriedade, o código interno para a classe poderá ter de ser ajustado para usar a variável privada ao invés da propriedade pública.
• Projeto de Ruby obriga todas as variáveis ​​de instância a serem privadas, mas também fornece uma maneira simples de declarar métodos set e get. Isto está de acordo com a ideia de que em Ruby, nunca se acessa diretamente os membros internos de uma classe de fora dela, mas sim, passa uma mensagem para a classe e recebe uma resposta .

Os Diferentes Comportamentos Comparado a Outras Linguagens

• A sintaxe da linguagem é case sensitive em todos os casos que tratam variáveis ​​maiúsculas como constantes.
• Nomes de classe e módulos são constantes e se referem a objetos derivados destes.
• Sigil $ e @ não indicam o tipo de variáveis de dados como em Perl, mas funcionam como operadores de resolução de escopo.
• Pontos flutuantes literais devem ter dígitos em ambos os lados do ponto decimal: nem .5 nem 2. são  pontos flutuantes literais de válidos, mas  deve ser usado 0.5 e 2.0 (Em Ruby, literais inteiros são objetos que podem ter métodos aplicam-se a eles, de modo que requer um dígito após um ponto decimal para ajudar a esclarecer se 1.e5 deve ser analisado de forma análoga à 1.to_f ou como o formato exponencial flutuante 1.0e5 literal. A razão para a necessidade de um dígito antes do ponto decimal é menos clara, que poderia dizer respeito a invocação de método novo, ou talvez para o .. e ... os operadores , por exemplo, no fragmento de 0,1 ... 3 . )
• Tipos de dados  booleanos não-booleanos são permitidos em contextos booleanos (ao contrário por exemplo, Java), mas seu mapeamento para valores booleanos difere marcadamente de alguns outras linguagem: 0 e "vazio" (por exemplo, lista vazia , string ou array associativo ), todos avaliados como verdade, alterando assim o significado de algumas expressões idiomáticas comuns em línguas relacionadas ou similares, tais como Lisp , Perl e Python.
• Uma consequência desta regra é que os métodos de Ruby por convenção - por exemplo, de buscas por expressão regular - retorna números, strings, listas ou outros valores não- falsos em caso de sucesso, mas nil em caso de falha.
• A indicação da notação até a expressão não executar a instrução se a expressão já é verdade. ( O comportamento é como Perl, mas ao contrário de declarações equivalentes de outras línguas, por exemplo, fazer declaração { } while ( (expressão) ); 
• Devido ser as constantes referências a objetos, mudar a referência de uma constante gera um aviso, mas alterar o objeto em si não gera. Por exemplo, Saudação << " mundo! " se saudação == " Olá " não gera um erro ou aviso.
• Isto é semelhante às variáveis ​​finais em Java ou a um ponteiro constante para um objeto não-constante em C++, mas o Ruby fornece a funcionalidade para "congelar" um objeto, ao contrário de Java.
• Os operadores usuais de expressões condicionais, and e or, não seguem as regras normais de precedência: and não tem liga mais firme do que or. Rubi também tem operadores de expressão || e && que funcionam como o esperado.

Interação

A distribuição oficial Rubi inclui um intérprete de linha de comando interativa, irb que pode ser usado para testar rapidamente o código. O seguinte fragmento de código representa uma sessão de amostra usando irb:

$ irb
irb(main):001:0> puts "Hello, World"
Hello, World
 => nil
irb(main):002:0> 1+2
 => 3 

Ruby Interative Shell (irb) é a interação da linguagem de script objeto orientado Ruby.

O IRB sigla vem do fato de que a extensão do arquivo para Ruby é ". Rb".

O programa é iniciado a partir de uma linha de comando e permite a execução de comandos de Ruby com resposta imediata, executado em tempo real.

Possui histórico de comandos, capacidades de edição de linha e controle de trabalho, e é capaz de se comunicar diretamente como um script shell através da Internet e interagir com um servidor ao vivo. 



Sintaxe de uso do programa:



irb [ options ] [ programfile ] [ argument... ]


Exemplo de sintaxe:


irb(main):001:0> n = 5
=> 5
irb(main):002:0> def fact(n)
irb(main):003:1>   if n <= 1
irb(main):004:2>     1
irb(main):005:2>   else
irb(main):006:2*     n * fact(n - 1)
irb(main):007:2>   end
irb(main):008:1> end
=> nil
irb(main):009:0> fact(n)
=> 120








Exemplos

Estes exemplos podem ser executados em um Ruby shell como irb, ou salvo em um arquivo e executado em uma linha de comando digitando ruby<filename>.

Clássico Hello world : 

puts "Hello World!"




Código Básico Ruby:


# Everything, including a literal, is an object, so this works:
-199.abs                                             # => 199
"ice is nice".length                                 # => 11
"ruby is cool.".index("u")                           # => 1
"Nice Day Isn't It?".downcase.split("").uniq.sort.join    
                                           # => " '?acdeinsty"




Conversões:


puts "Give me a number"
number = gets.chomp
puts number.to_i
output_number = number.to_i + 1
puts output_number.to_s + ' is a bigger number.'







String




Há várias maneiras de definir strings em Ruby.

As seguintes atribuições são equivalentes e suportam interpolação de variáveis: 

variable interpolation (também a substituição de variáveis ​​ou a expansão de variáveis​​) é o processo de avaliação de uma expressão ou string literal contendo uma ou mais variáveis​​, gerando um resultado em que as variáveis ​​são substituídas por seus valores correspondentes na memória. É uma instância especializada de concatenação.





a = "\nThis is a double-quoted string\n"
a = %Q{\nThis is a double-quoted string\n}
a = %{\nThis is a double-quoted string\n}
a = %/\nThis is a double-quoted string\n/
a = <<-BLOCK
 
This is a double-quoted string
BLOCK






Raw strings (strings brutas) - Algumas linguagens fornecem um método de especificar que um literal é para ser processado sem qualquer interpretação específica da linguagem. Isto evita a necessidade de escape, e produz strings mais legíveis.

Strings brutas são particularmente úteis quando um caractere comum precisa usar escape, especialmente em expressões regulares, onde barra invertida \ é amplamente utilizado, e em caminhos de DOS/Windows, onde barra invertida é usada como separador de caminho. 

A profusão do invertidas é conhecida como síndrome de inclinar-se palito, e pode ser reduzido pelo uso de strings brutas. Compare escapes e caminho bruto:


 "The Windows path is C:\\Foo\\Bar\\Baz\\"
 r"The Windows path is C:\Foo\Bar\Baz\"







Os seguintes atributos são equivalentes e produz raw strings:




a = 'This is a single-quoted string'
a = %q{This is a single-quoted string}







Collections




Construindo e usando um array:


a = [1, 'hi', 3.14, 1, 2, [4, 5]]
 
a[2]                    # => 3.14
a.[](2)                 # => 3.14
a.reverse               # => [[4, 5], 2, 1, 3.14, 'hi', 1]
a.flatten.uniq          # => [1, 'hi', 3.14, 2, 4, 5]






Construindo e usando um  associative array (em Ruby, chamado de hash):

Array associativa, mapa, tabela de símbolos, ou dicionário é um tipo abstrato de dados composto por uma coleção de (chave, valor) pares, de modo que cada chave possível aparecer no máximo uma vez na coleção.




hash = Hash.new     # equivalent to hash = {}


# makes the previous line redundant as we are now
hash = { :water => 'wet', :fire => 'hot' } 

# assigning hash to a new, separate hash object
puts hash[:fire] # prints "hot"
 
# or: hash.each do |key, value|
hash.each_pair do |key, value|
  puts "#{key} is #{value}"
end
# returns {:water=>"wet", :fire=>"hot"} and prints:
# water is wet
# fire is hot
 
# deletes the pair :water => 'wet' and returns "wet"
hash.delete :water   

# deletes the pair :fire => 'hot' and returns {}
hash.delete_if {|key,value| value == 'hot'}

Ruby 1

Ruby

Ruby é uma linguagem de programação dinâmica ¹ , reflexiva ², orientada a objetos ³, e de uso geral. Encarna inspirado em Perl com características Smalltalk - como sintaxe e também foi influenciado por Eiffel e Lisp. 

Ela suporta múltiplos paradigmas de programação, incluindo o funcional ⁴, orientação a objetos, e imperativo. Também tem um sistema de tipo dinâmico e gerenciamento automático de memória. Portanto, é semelhante em diferentes graus a Smalltalk , Python, Perl, Lisp, Dylan, e CLU .

A partir de 2010 , há uma série de implementações alternativas completas ou próximos do Ruby, incluindo YARV, JRuby, Rubinius, IronRuby, MacRuby ( e sua contraparte iOS , RubyMotion), mruby, HotRuby, Topaz e Opal. Cada tem uma abordagem diferente, com IronRuby, JRuby, MacRuby e Rubinius fornecendo compilação just-in-time.

Características do Ruby

• Completamente orientada a objetos com herança, mixins (classe que contem uma combinação de métodos de outras classes) e metaclasses (classe cujas instância são classes).
• Tipagem dinâmica e 'duck typing'(não requer a declaração do tipo da variável).
• Tudo é uma expressão (até mesmo declarações) e tudo é executado imperativamente (mesmo declarações)
• Sintaxe sucinta e flexível que minimiza o ruído sintático e serve como base para linguagens específicas de domínio.
• Reflexão dinâmica e alteração de objetos para facilitar a metaprogramação.
• Fechamentos léxicos, 'iteration' (objeto que permite tratar com contêineres, como listas ) e 'generator' (rotina usada para controlar o comportamento de uma 'iteration' em um loop), com um único bloco sintático.
• Notação literal para arrays, hashes , expressões regulares e símbolos
• Incorporação de código em strings (interpolação)
• argumentos defaults
• Quatro níveis de alcance variável (global, classe, instância e local) denotado por sigil(símbolo junto dos nomes das variáveis mostrando o tipo ou escopo, um prefixo como $foo, %foo, @foo) ou a falta dele.
• A coleta de lixo.
• Continuações de primeira-classe.
• Regras rígidas de coerção booleanos (tudo é verdadeiro, exceto false e nil [o ponteiro não aponta para objeto válido]).
• A manipulação de exceção.
• Sobrecarga de operadores.
• O suporte integrado para os números racionais, números complexos e aritmética de precisão arbitrária
• Comportamento de envio personalizado(através method_missing e const_missing )
• Threads nativas e fibras cooperativas (threads de execuções leves )
• O suporte inicial para Unicode e várias codificações de caracteres (não suporta ICU)
• Plug-in API nativa em C.
• Ruby Shell interativa  (um REPL [ read–eval–print loop (REPL) é um simples ambiente de programação interativo]).
• Gerenciamento de pacotes centralizado através RubyGems
• Implementado em todas as principais plataformas.
• Grande biblioteca padrão.

Semântica do Ruby

Ruby é orientada a objetos: 
a cada valor é um objeto, incluindo classes e instâncias de tipos que muitas outras línguas designam como primitivas (como inteiros , booleanos , e "null").

• Variáveis ​​sempre contêm referências a objetos.
• Cada função é um método e métodos são sempre chamados em um objeto.
• Métodos definidos no escopo de alto nível tornam-se membros da classe Object.
• Uma vez que esta classe é um ancestral de todas as outras classes, tais métodos podem ser chamados em qualquer objeto. Eles também são visíveis em todos os âmbitos , efetivamente servindo como procedimentos "globais".
• Rubi suporta herança com envio dinâmico, mixins e métodos singleton ( pertencentes a, e definidos para uma única instância em vez de ser definido na classe ).
• Apesar de Ruby não suporta herança múltipla, classes podem importar módulos como mixins .
• Rubi tem sido descrito como uma linguagem de programação multi-paradigma: permite programação procedural (definindo funções/ variáveis ​​fora das classes tornando as parte da raiz, 'self' Object), como orientação a objetos (tudo é um objeto) ou programação funcional (tem funções anônimas, fechamentos e continuações; declarações têm todos valores, e as funções retornam a última avaliação).
• Ele tem suporte para a introspecção, reflexão e meta-programação, bem como suporte para threads baseadas em interpretação.
• Ruby tem tipagem dinâmica, e suporta polimorfismo paramétrico .

Dinâmica  ¹ é uma classe de linguagens de programação de alto nível que, em tempo de execução, executar muitos comportamentos comuns que outras línguas pode realizar durante a compilação. Esses comportamentos podem incluir a extensão do programa, através da adição de um novo código, estendendo objetos e definições, ou modificando o sistema de tipos, todos durante a execução do programa. Esses comportamentos podem ser emulado em quase qualquer linguagem de complexidade suficiente, mas linguagens dinâmicas fornecem ferramentas diretas para fazer uso deles.

A maioria das linguagens dinâmicas também são 'typed' de forma dinâmica, mas nem todos são. As linguagens dinâmicas podem ser (mas não sempre), frequentemente referido como "linguagens de script", no entanto, que poucos artigos se referem a linguagens específicas de um determinado ambiente.

Reflexiva ² é a capacidade de um programa de computador de analisar e modificar a estrutura e o comportamento (especificamente os valores, meta-dados, propriedades e funções) de um objeto em tempo de execução.

A reflexão é mais comumente usado em alto nível linguagens de programação da máquina virtual, como linguagens de script e também em linguagens de programação manifestamente digitados ou de tipagem estática.

Pode ser usada para observar e / ou modificar a execução do programa durante a execução. Um componente de programa orientado a reflexão pode monitorar a execução de um corpo de código e pode modificar-se de acordo com um objetivo desejado relacionada a esse código. Isso normalmente é realizado através da atribuição dinamicamente código do programa em tempo de execução .

Em linguagens de programação orientadas a objeto como Java, a reflexão permite inspeção de classes, interfaces, campos e métodos em tempo de execução sem saber os nomes das interfaces, campos, métodos em tempo de compilação. Ele também permite a instanciação de novos objetos e invocação de métodos.

Reflexibilidade também pode ser utilizada para adaptar dinamicamente um programa a diferentes situações. Por exemplo, considere um aplicativo que usa duas classes diferentes X e Y de forma intercambiável para executar operações similares. 

Sem programação orientada a reflexão, o aplicativo deve ser rigidamente codificado para chamar nomes de métodos de classe X e  classe Y. No entanto, utilizando o paradigma de programação orientada a reflexão, o aplicativo poderia ser concebido e escrito para utilizar reflexão para invocar métodos em classes X e Y, sem nomes de métodos rígidos de codificação.

Programação orientada a reflexão quase sempre requer conhecimento adicional, estrutura, mapeamento relacional e relevância objeto, a fim de aproveitar a execução de código mais genérico. Rigidez de codificação pode ser evitada com o uso de programação orientada a reflexão.

A reflexão é muitas vezes usado como parte de testes de software, tais como o tempo de execução para a criação / instanciação de objetos simulados. A reflexão é também uma estratégia fundamental para metaprogramação.

Uma linguagem de apoio reflexão fornece uma série de recursos disponíveis em tempo de execução que seriam muito difíceis de realizar em uma linguagem de baixo nível. Algumas destas características são as habilidades:

• Descobrir e modificar construções de código fonte (como blocos de código, classes, métodos, protocolos, etc) como um objeto de primeira-classe em tempo de execução .
• Converte uma string correspondente ao nome simbólico de uma classe ou função em uma referência ou invocação de que classe ou função.
• Executa uma string como se fosse uma declaração de código-fonte em tempo de execução .
• Criar um novo intérprete de bytecode da linguagem para dar um novo significado ou propósito para a construção de programação .

Estas características podem ser aplicadas de diferentes maneiras .

Os seguintes trechos de código cria uma instância foo da classe  FOO, e invocar o seu método hello(). Para cada linguagem de programação, as sequências normais e baseado em reflexão de chamadas são mostrados.

Ruby

# sem reflexão
obj = Foo.new
obj.hello
 
# com reflexão
class_name = "Foo"
method = :hello
obj = Kernel.const_get(class_name).new
obj.send method
 
# com eval
eval "Foo.new.hello"

Java

// sem reflexão
Foo foo = new Foo();
foo.hello();
 
// com reflexão
Object foo = Class.forName("complete.classpath.and.Foo").newInstance();
Method m = foo.getClass().getDeclaredMethod("hello", new Class<?>[0]);
m.invoke(foo);

Programação orientada a objetos (OOP) ³ é um paradigma de programação que representa conceitos como "objetos" que têm campos de dados (atributos que descrevem o objeto) e procedimentos associados, conhecidos como métodos. Objetos, que geralmente são instâncias de classes, são usados ​​para interagir uns com os outros para projetar aplicativos e programas de computador. C++, Objective-C, Smalltalk, Java, C #, Perl, Python e PHP são exemplos de objeto orientada linguagens de programação.

Funcional ⁴ é um paradigma de programação, um estilo de construção da estrutura e elementos de programas, que trata a computação como a avaliação de funções matemáticas e evita estados e dados mutáveis ​. A programação funcional enfatiza funções que produzem resultados que dependem apenas de suas entradas, e não sobre o estado do programa - funções matemáticas ou seja, puras.

É um paradigma de programação declarativa, o que significa que a programação é feita com expressões. No código funcional, o valor de uma função de saída depende apenas dos argumentos que são entrada para a função, por isso chamada de uma função f duas vezes com o mesmo valor para um argumento x irá produzir o mesmo resultado f (x) duas vezes.

 Eliminando os efeitos colaterais, ou seja, mudanças de estado que não dependem das entradas da função, pode torná-lo muito mais fácil de compreender e prever o comportamento de um programa, que é uma das principais motivações para o desenvolvimento de programação funcional.

A programação funcional tem suas raízes no cálculo lambda, um sistema formal desenvolvido na década de 1930 para investigar computabilidade, o problema Entscheidungs, definição de função, aplicação de função, e recursão.

 Muitas linguagens de programação funcionais podem ser vistas como elaborações sobre o cálculo lambda. No outro bem conhecido paradigma de programação declarativa, programação lógica , as relações estão na base das respectivas linguagens.

JOBS TIPS

http://interviewmastersystem.com/thank-you-2/

Buffer Cache Hit Ratio Oracle Tuning Performance

Buffer Cache Hit Ratio

https://www.simple-talk.com/sql/database-administration/great-sql-server-debates-buffer-cache-hit-ratio/


http://www.dbspecialists.com/files/presentations/buffercache.html

http://www.fadalti.com/oracle/database/how_to_statspack.htm

http://victor-dba.blogspot.com.br/2012/02/scripts-monitores-de-performance.html

Oracle® Database Performance Tuning Guide

Oracle® Database Performance Tuning Guide

http://docs.oracle.com/cd/B19306_01/server.102/b14211/toc.htm

pHmetro Caseiro

Medidor de pH “caseiro”

Um indicador de pH alternativo é o sumo da couve-roxa (ou o caldo onde foi cozida). Segue abaixo, os passos para o teste.

Material básico necessário:

- Folhas de repolho roxo
- Recipientes para armazenamento
- Peneira
- Líquido a ser avaliado

Procedimento:

- Separe e pique algumas folhas de repolho roxo dentro de um recipiente que possa ser levado ao fogo, adicione um pouco de água e ferva por 10 minutos para a infusão. Deixe esfriar, coe e reserve. Então, este será o líquido indicador.

- Coloque o líquido, como por exemplo, água (seja de rio, lago, poço ou chuva), em um recipiente e jogue o líquido indicador. Observe a cor, em seguida, utilize a escala abaixo para classificação.

Escala de pH – “Indicador de Couve-Roxa”

Imagem 1 – Escala de pH – “Indicador de Couve-Roxa”

Alguns valores comuns de pH