COMPARAÇÕES

A comparação entre dois números é a forma mais comum de se usar os recursos de uma linguagem de programação para conseguir distinguir os dois números segundo a condição imposta (diferença, igualdade, maior, menor, primo, par, etc).
É primordial a dominação do uso dos loops, condições (for, while, if, etc), sinais de comparação e operadores matemáticos, etc. A comparação entre os elementos de uma lista entre si ou com outra lista requer um código mais elaborado tendo em vista a possibilidade de repetição de elementos em uma mesma lista.

1. Diferenças entre =, == e ===
Estes três sinais são parecidos, porém com resultados bem diferentes.
1.1. = é um operador de atribuição, ou seja, utilizado para atribuir um valor a uma variável.
Ex: var a = 10; var b="10"; Observe que a ≠ b, pois a é do tipo número e b é do tipo texto.

1.2. == é um operador de comparação de igualdade cuja variável é do tipo boleano, ou seja, pode retornar true ou false. A igualdade não leva em consideração o tipo. O operador de comparação de desiqualdade é !=.
Exemplo: Para a = 10;
a == 5 retorna false.
a == 10 retorna true.
a == "10" retorna true. Converte o tipo número para texto.

1.3. === é um operador de comparação de igualdade estrita que retorna true ou false. A igualdade leva em consideração o tipo. O operador de comparação de desigualdade estrita é !==.
Exemplo: Para a = 10;
a === 5 retorna false.
a ===10 retorna true.
a === "10" retorna false.
Obs:
- O sinal de exclamação (!) inverte o valor.
- var a; esta variável é declarada, mas não é definida, retornar undefined. Um variável é definida quando é atribuido (=) um valor a mesma.
- Para efeito de comparação, undefined e null são iguais (==), mas não idênticos (===).

Sameness Comparisons
x y ==
===
Object.is SameValueZero
undefined undefined true true true true
null null true true true true
true true true true true true
false false true true true true
'foo' 'foo' true true true true
0 0 true true true true
+0 -0 true true false true
+0 0 true true true true
-0 0 true true false true
0 false true false false false
""
false true false false false
""
0 true false false false
'0' 0 true false false false
'17' 17 true false false false
[1, 2] '1,2' true false false false
new String('foo') foo' true false false false
null undefined true false false false
null false false false false false
undefined false false false false false
{ foo: 'bar' } { foo: 'bar' } false false false false
new String('foo') new String('foo') false false false false
0 null false false false false
0 NaN false false false false
'foo' NaN false false false false
NaN NaN false false true true
Fonte: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness
Data da pesquisa: 12/10/2019

Testando um valor NaN
The Number.isNaN() method determines whether a value is NaN (Not-A-Number).
Os operadores de igualdade (== e ===) não podem ser usados para testar um valor NaN. Ao invés disso, utilize Number.isNaN() ou isNaN().
NaN === NaN;// falso
Number.NaN === NaN; // falso
isNaN(NaN);  // verdadeiro
isNaN(Number.NaN);
// verdadeiro
Fonte: https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NaN
Data da pesquisa: 12/10/2019

Boolean Values
A JavaScript Boolean represents one of two values: true or false.
Very often, in programming, you will need a data type that can only have one of two values, like.
YES or NO.
ON or OFF.
TRUE or FALSE (javascript: true == 1 e false == 0).
For this, JavaScript has a Boolean data type. It can only take the values true or false.
The Boolean() Function return true or false.
Referência: https://www.w3schools.com/js/js_booleans.asp.
Data pesquisa: 13/10/19.

Example: arquivo boolean1.html:
<html lang="pt_BR">
<head>
<meta charset="utf-8">
</head>
<body>
<script>
function comparar() {
var var1 = 'true' == true;
var var2 = '0' == false;
var var3 = null == undefined;
var var4 = false == null;
var var5 = null == 0;
var var6 = '' == 0;// duas aspas simples
var var7 = '\t\n' == 0;
var var8 = '1' == true;

document.writeln("Boolean(10 > 9) return "+Boolean(10 > 9)+"<br>");
document.writeln("Boolean('true' == true) return "+Boolean('true' == true)+"<br>");
document.writeln("Boolean('0' == false) return "+Boolean('0' == false)+"<br>"); 
document.writeln("Boolean(null == undefined) return "+Boolean(null == undefined)+"<br>");
document.writeln("Boolean(false == null) return "+Boolean(false == null)+"<br>");
document.writeln("Boolean(null == 0) return "+Boolean(null == 0)+"<br>");
document.writeln("Boolean('' == 0) return "+Boolean('' == 0)+"<br>");
document.writeln("Boolean('\t\n' == 0) return "+Boolean('\t\n' == 0)+"<br>");
document.writeln("Boolean('1' == true) return "+Boolean('1' == true)+"<br>"); 
document.writeln("Boolean(0 == false) return "+Boolean(0 == false)+"<br>"); 
document.writeln("Boolean(1 == true) return "+Boolean(1 == true)+"<br>");
document.writeln("Boolean(0 === false) return "+Boolean(0 === false)+"<br>");
document.writeln("Boolean(1 === true) return "+Boolean(1 === true)+"<br>");
document.writeln("Boolean(2 == true) return "+Boolean(2 == true)+"<br>");
document.writeln("Boolean(2 == false) return "+Boolean(2 == false)+"<br>");
}
comparar();
</script>
</body>
</html>
Resultado:
Boolean(10 > 9) return true
Boolean('true' == true) return false
Boolean('0' == false) return true
Boolean(null == undefined) return true
Boolean(false == null) return false
Boolean(null == 0) return false
Boolean('' == 0) return true
Boolean(' ' == 0) return true
Boolean('1' == true) return true
Boolean(0 == false) return true
Boolean(1 == true) return true
Boolean(0 === false) return false
Boolean(1 === true) return false
Boolean(2 == true) return false
Boolean(2 == false) return false

2. Array
Esta apostila trata-se de práticas, portanto irei abordar o mínimo de definições.
Array é uma sequência disposta geralmente em linha, ordenada através de índices que indicam a linha e a coluna de cada elemento. O primeiro índice é 0 (zero).
2.1. Array (índices)
O arquivo abaixo imprime os índices de um array de apenas uma linha.
Exemplo: impressão dos indices e do tamanho do array.
Arquivo: for1.html
<html lang="pt_BR">
<head>
<meta charset="utf-8">
</head>
<body>
<script>
function vai() {
var lista1=[10,20,30,40,50];
    for(i=0;i<=lista1.length-1;i=i+1){
     document.writeln("lista1[i] = "+lista1[i]+" indice = " +i+"<br>");
   }
document.writeln("lista1.length = "+lista1.length+"<br>");
}
vai();
</script>
</body>
</html>
Resultado:
lista1[i] = 10 indice = 0
lista1[i] = 20 indice = 1
lista1[i] = 30 indice = 2
lista1[i] = 40 indice = 3
lista1[i] = 50 indice = 4
lista1.length = 5
Obs: último índice tem tamanho igual a lista1.length-1.

2.1.1. Array (combinação de dois indices)
A comparação entre dois elementos de um array requer logicamente dois índices, um para cada elemento. Vejamos como se comportam os contadores de dois laços for um interno ao outro.
Código
<html lang="pt_BR">
<head>
<meta charset="utf-8">
</head>
<body>
<script>
function vai() {
lista1=[1,1,1,2,3,4,5,6,7,3,5,8,9,10,1,1,2,2,2,2,1,1];
    for(i=0;i<=lista1.length-2;i=i+1){
        document.writeln("indice i = "+i+"<br>");//cada ciclo i pula uma linha
        document.writeln("indice j = ");//cada ciclo i após pular uma linha começa a escrever
               for(j=0;j<=lista1.length-1;j=j+1){
               document.writeln(j+",");  
               }  //inicia novo ciclo j enquanto true 
               document.writeln("<br>"); //final do ciclo j pula uma linha
   }//inicia novo ciclo i enquanto true
}
vai();
</script>
</body>
</html
Resultado
indice i = 0
indice j = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
indice i = 1
indice j = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
indice i = 2
indice j = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
...
Comentário:
- Cada elemento do for externo corresponde a um ciclo completo do for interno.

2.2. Comparação Dentro do Array
A figura abaixo mostra a seqüência de comparações entre os elementos do próprio array de uma linha. Um array é um conjunto, coleção, lista ou seqüência ordenada de elementos. Os elementos de uma array se encaixam perfeitamente em uma tabela.
A comparação é feita com duas listas iguais.

A comparação começa com o primeiro elemento que é comparado com todos os elementos que estão a sua frente. A comparação é sempre feita com os elementos da sua frente porque a comparação com os elementos anteriores já foram feitas pelas comparações anteriores. Logicamente que nenhum elemento faz a comparação com ele próprio. Esse processo se repete até o penúltimo elemento que é comparado com o último.

A comparação da figura abaixo é mais completa e serve também para comparar elementos de uma mesma lista, é melhor que a da figura acima.



2.2.1. Retirar Elemento Repetido do Array
O código abaixo retira com o uso de método splice() o elemento repetido do array. Repare na complexidade das comparações, um laço while interno ao laço for e ambos ao for externo. Este código foi conseguido através de vários testes realizados. O ciclo do segundo for inicia igual a i+1 (ii).
Exemplo: arquivo comapa1.html
<html lang="pt_BR">
<head>
<meta charset="utf-8">
</head>
<body>
<script>
function vai() {
lista1=[1,1,2,3,4,5,6,7,3,5,8,9,10,1,1,2,2,2,2];
lista2=lista1;
var ii=0;//deslocamento do ciclo
    for(i=0;i<=lista1.length-2;i=i+1){//pega cada elemento de lista1 até o penultimo elemento
        ii=ii+1;//índice da frente dos elementos pegos pelo primeiro for
             for(j=ii;j<=lista1.length-1;j=j+1){//para cada elemento pego de lista1 percorre os elementos da frente 
                  while (lista1[i]==lista1[j]) {//enquanto os elementos forem iguais retire o segundo igual
                       lista1.splice(j, 1); 
                  }
            }
   }
   for(i=0;i<=lista1.length-1;i=i+1){//impressão na tela
      document.writeln("x"+i+" = "+lista1[i]+"<br>");
   }
}
vai();
</script>
</body>
</html
Resultado:
x0 = 1
x1 = 2
x2 = 3
x3 = 4
x4 = 5
x5 = 6
x6 = 7
x7 = 8
x8 = 9
x9 = 10

Comentário:
- O contador i do primeiro for começa com 0 (zero) e termina igual ao penúltimo índice da lista1 (lista1.length-2).
- Para cada i do primeiro for o contador j do segundo for percorre um ciclo de ii até o último elemento da lista1.
- O contador ii é sempre 1 (um) a mais que i e j = ii. ii=i+1
- Conforme testes realizados o laço while executa a condição enquanto ela é verdadeira. O laço for interno percorrer o seu contador, enquanto a condição do while é verdadeira  o elemento de índice j é retirado e  o próximo elemento do array assume a posição do elemento que saiu e um novo teste é feito.
- O método lista1.splice(j, 1) retira o elemento lista1[j] que é repetido

2.2.2. Pegar Elementos Não Repetidos do Array
O código abaixo pega os elementos que não se repetem. A condição i!=j do primeiro if é necessária porque um elemento é sempre igual a ele mesmo, assim, eliminamos essa possibilidade. A condição jj==lista1.length-1 do segundo if garante que todas as comparações são verdadeiras, ou seja, o elemento é diferente de todos da lista. O ciclo do segundo for é completo conforme figura anterior.
Código:
<html lang="pt_BR">
<head>
<meta charset="utf-8">
</head>
<body>
<script>
function vai() {
lista1=[1,1,1,2,3,4,5,6,7,3,5,8,9,10,1,1,2,2,2,2,1,1];
lista2=[];
    for(i=0;i<=lista1.length-2;i=i+1){
        var jj=0;//contador de verdades do primeiro if
               for(j=0;j<=lista1.length-1;j=j+1){//ciclo completo
                     if(lista1[i]!=lista1[j]&&i!=j) {//se elemento diferente e índice diferente
                      jj=jj+1;//quantidade de condições verdadeiras  
                          if(jj==lista1.length-1){lista2.push(lista1[i]);}//se elemento é diferente de todos
                     }                     
               }  //inicia novo ciclo j
   }//inicia novo ciclo i
          for(i=0;i<=lista2.length-1;i=i+1){//impressão na tela
          document.writeln("x"+i+" = "+lista2[i]+"<br>");
       }
}
vai();
</script>
</body>
</html
Resultado
x0 = 4
x1 = 6
x2 = 7
x3 = 8
x4 = 9
x5 = 10

2.2.3. Pegar Elementos Repetidos do Array Uma Vez
Para pegar os elementos repetidos o código é parecido com o anterior, o primeiro if muda para igualdade. No segundo if a quantidade de condições verdadeira é só a primeira (jj==1), isso porque caso haja repetição de um elemento tal elemento não seja inserido novamente no liste2. Outra condição do segundo if é i < j que garante pegar apenas a primeira igualdade de todas as comparações. O ciclo do segundo for é completo conforme figura anterior.

Código:
<html lang="pt_BR">
<head>
<meta charset="utf-8">
</head>
<body>
<script>
function vai() {
lista1=[1,1,1,2,3,4,5,6,7,3,5,8,9,10,1,1,2,2,2,2,1,1];
lista2=[];
    for(i=0;i<=lista1.length-2;i=i+1){
        var jj=0;
               for(j=0;j<=lista1.length-1;j=j+1){
                     if(lista1[i]==lista1[j]&&i!=j) {//se elemento igual e índice diferente
                      jj=jj+1;//quantidade de condições verdadeiras  
                           if((jj==1)&&(i<j)){lista2.push(lista1[i]);}//se primeira condição verdadeira e validade só par frente
                     }                     
               }  //inicia novo ciclo j
   }//inicia novo ciclo i
          for(i=0;i<=lista2.length-1;i=i+1){//impressão na tela
          document.writeln("x"+i+" = "+lista2[i]+"<br>");
       }
}
vai();
</script>
</body>
</html>
Resultado
x0 = 1
x1 = 2
x2 = 3
x3 = 5

2.2.4. Tirar os Elementos Repetidos de Um Array
É só juntar os dois códigos anteriores. Ou seja, juntar os elementos que não são repetidos com os elementos que eram repetidos.
Código
<html lang="pt_BR">
<head>
<meta charset="utf-8">
</head>
<body>
<script>
function vai() {
lista1=[1,1,1,2,3,4,5,6,7,3,5,8,9,2,10,1,1,2,2,2,2,1,11,1,1,34,2,5,6,7,8];
var pega1=[];

//pegar elementos diferentes
    for(i=0;i<=lista1.length-2;i=i+1){
                       var v1=0;
            for(ii=0;ii<=lista1.length-1;ii=ii+1){

                if(lista1[i]!=lista1[ii]&&i!=ii) {
                 v1=v1+1;
                 if(v1==lista1.length-1) {pega1.push(lista1[i]);}  
                }
            }      
    }
           
 //pegar elementos repetidos
  for(i=0;i<=lista1.length-2;i=i+1){
        var jj=0;
               for(j=0;j<=lista1.length-1;j=j+1){
                     if(lista1[i]==lista1[j]&&i!=j) {//se elemento igual e índice diferente
                      jj=jj+1;//quantidade de condições verdadeiras 
                           if((jj==1)&&(i<j)){pega1.push(lista1[i]);}//se primeira condição verdadeira e validade só par frente
                     }                    
               }  //inicia novo ciclo j
   }//inicia novo ciclo i
          for(i=0;i<=pega1.length-1;i=i+1){//impressão na tela
          document.writeln("x"+i+" = "+pega1[i]+"<br>");
          }
}
vai();
</script>
</body>
</html>
Resultado
x0 = 4
x1 = 9
x2 = 10
x3 = 11
x4 = 34
x5 = 1
x6 = 2
x7 = 3
x8 = 5
x9 = 6
x10 = 7
x11 = 8

2.2.5. Pegar Elementos Comuns de Dois Array Uma Vez
O código abaixo é muito parecido com o anterior, a comparação do primeiro if não precisa da condição i!=j, pois há duas listas diferentes, portanto a comparação entre os elementos pode ser com indices iguais. Acrescenta-se o array lista2, o resto do código é apenas uma adaptação do código anterior.
Código:
<html lang="pt_BR">
<head>
<meta charset="utf-8">
</head>
<body>
<script>
function vai() {
lista1=[1,1,1,2,3,4,5,6,7,3,5,8,9,2,10,1,1,2,2,2,2,1,11,1,1,34,2,5,6,7,8];
lista2=[1,1,1,2,3,4,5,6,11,22,44,55,6,77,8,8,1000];
lista3=[];
    for(i=0;i<=lista1.length-1;i=i+1){
        var jj=0;
               for(j=0;j<=lista2.length-1;j=j+1){//ciclo completo
                     if(lista1[i]==lista2[j]) {//se elemento iguais
                      jj=jj+1;//quantidade de condições verdadeiras                     
                     if((jj==1)&&(i<=j)){lista3.push(lista1[i]);}//se primeira condição verdadeira
                     }                     
               }  //inicia novo ciclo j
   }//inicia novo ciclo i
          for(i=0;i<=lista3.length-1;i=i+1){//impressão na tela
          document.writeln("x"+i+" = "+lista3[i]+"<br>");
       }
}
vai();
</script>
</body>
</html>
Resultado
x0 = 1
x1 = 2
x2 = 3
x3 = 4
x4 = 5
x5 = 6
x6 = 8