JOTA LAGO (40 pts)

JONAS GALVEZ (521 pts)

MUZAK (45 pts)

ILVA RUDEV (90 pts)

PEDRO CLAUDIO (50 pts)

ÉMERSON ROCHA (85 pts)

AMAURY BENTES (123 pts)

BÁRBARA TOSTES (64 pts)

LUIZ HERRERA (117 pts)

AUTOR DESCONHECIDO (100 pts)

SÁVIO PONTE (39 pts)

RÔMULO NUNES (32 pts)
Treinamento PontoFlash de Flash e ActionScript

Como fazemos um objeto andar para frente e para trás por meio de um botão (roll over e roll out).

Dicas para fazer um executável no flash.

Como criar membros (*propriedades e métodos) PRIVADOS de classes (OOP)?

Como fazer um executável no Flash com autorun?

Existe um modo de fazer tellTarget em vários MCs ao mesmo tempo?

Porque imagens TIFF têm melhor qualidade do que as imagens em .JPG (1).

Como faço para fazer um autorun?

Problemas com manter duas instâncias duplicadas na mesma cena.

O que fazer para que um objeto se afaste do mouse.

Alguém sabe como usar o swapDepths?

Como publicar um .SWF e fazer com que ele não mostre outra fonte?

Como fazer um duplicateMovieclip em um movieclip quando solto em uma determinada área?

Como eu faço para eliminar as barras de rolagem do navegado IE.

Como é que eu faço um efeito de um objeto crescendo e entrando em foco?
Usando Define Patern para criar texturas contínuas no PhotoShop.

Variáveis do servidor ASP em ambiente flash

Controle de som no Flash 5.

Movimento por meio de actionscript

GetMySQLData para Flash5 (segunda parte)

Fade Out.

A história do Flash.

Code Animation - Parte 2

Desenhando apenas com Actionscript.

Jogo de colorir.

Color changer

Tratamento de um bitmap PNG com o PhotoShop.
Volume mixer

Alfabetar com colunas

F5menu popup

Natal Noel

3d frame by frame

Menu popop de pastas

Mouse delay

Pop menu

LoadVars

Waterfall

Tocha de fogo

Regressivo
HOME | TUTORIAIS
Objeto Array: métodos sort() e reverse().
por Anderson Arboleya

Este Tutorial tem como objetivo capacitar você, leitor, a utilizar dois métodos muito interessantes do Objeto Array, que são o método sort() e o método reverse().

     • Método sort()
          - Deixaremos clara sua aplicação;
          - Denotaremos sua deficiência e ensinaremos, com exemplos práticos e soluções já      prontas, como contorná-las a fim de obtermos o resultado desejado em nossas      aplicações;

     • Método reverse()
          - Deixaremos transparente como e para quê utilizá-lo, principalmente em      conjunto com o método sort() e com as funções que criaremos no decorrer deste      Tutorial;

     Introdução ao Tutorial

    Bom, antes de iniciarmos, convém frisar que para um entendimento completo desse tutorial, bem como de sua usabilidade, é desejável já ter algum conhecimento do objeto Array (Matriz), o que sem dúvidas facilitará muito sua assimilação e aprendizado.

     Porém, ainda assim, daremos uma leve explanada no objeto Array, para não iniciarmos do zero.

     Introdução ao Objeto Array

     Como sabemos, uma Array nada mais é do que uma espécie de "Armazenador de Dados", onde cada um de seus itens corresponde à uma posição (ou um índice) numérica(o), sendo que cada qual é divido por uma vírgula (","):

1
 myArray = ["pos01", "pos02", "pos03"];
2
 trace(myArray[0]); // Retorna: pos01
3
 trace(myArray[1]); // Retorna: pos02
4
 trace(myArray[2]); // Retorna: pos03

     No exemplo acima, temos uma array com três posições. Porém, como a primeira posição de uma Array é sempre "0" (zero), teremos em nossa Array, as posições "0" (zero),"1" (um) e "2" (dois), perfazendo um total de 3 (três) posições por fim.

     Logo, como foram exibidas no exemplo acima, para sabermos o conteúdo de cada posição, devemos invocar nossa array seguida da posição (índice) de onde desejamos extrair o valor, que deve ser informado cercado por colchetes "[]", veja:

1
 // Para a posição um, usamos como identificador, o número 0 :
2
 trace(myArray[0]); // Retorna: pos01
3
 
4
 // Para a posição dois, usamos como identificador, o número 1:
5
 trace(myArray[1]); // Retorna: pos02
6
 
7
 // Para a posição três, usamos como identificador, o número 2 :
8
 trace(myArray[2]); // Retorna: pos03
9
 
10
 /* ## Identificador = Índice ##*/

     E assim por diante...

     Bom, agora que já demos uma leve explanada no objeto Array, partiremos para o foco principal deste tutorial.


     1.0 - Introdução

     Muitas vezes precisamos ordenar certas listas de valores que guardamos em Arrays - sejam elas listas de cadastros de usuários, de funcionários, de produtos, de valores, enfim, qualquer lista que se possa criar - por qualquer critério que se queira.

     Para isto, existe um método muito interessante e útil do objeto Array, que é o método sort().

     Para cada tipo de lista, podemos ter uma necessidade de ordenação diferente, de acordo com as exigências da aplicação que estivermos usando.

     Sintetizando a função do método sort() em poucas palavras, podemos dizer seguramente que sua aplicação se limita a uma só ação: Organizar/Ordenar listas de dados em Arrays (Matrizes). Com valores não-Numéricos (string), a organização é feita por Ordem Alfabética; com valores numéricos, do menor para o maior, ou seja, de modo crescente.

     Mesmo com todas as explicações teóricas dadas até aqui, você ainda deve estar se perguntando:
     _
"Já entendi mas, me dê um exemplo PRÁTICO de quando poderei utilizar este recurso".
     Então vamos lá!

     1.1 - Exemplos de usabilidade

     Vamos dar uma olhada agora em várias situações-exemplo de onde poderíamos aplicar o método sort():

     - Suponhamos que temos uma lista de nomes, seja lá do que for: de pessoas, de produtos, de carros... enfim, de qualquer coisa, e temos que exibí-los por ordem alfabética;
     - Temos uma outra lista com vários anos de carros, e temos que exibí-los em ordem crescente ou decrescente;
     - Temos uma lista com vários valores e temos que exíbi-los na ordem crescente;

     Enfim, existem "N" possibilidades de aplicação para esse método de ordenação, o método sort().

     Agora que já vimos a parte Teórica da coisa, e que todos já devem estar cansados desta "enrolação", vamos para a parte que interessa: A parte prática!


     2.0 - Aplicação do Método sort()

     Vamos ver agora todas as maneiras para utilizarmos o método sort(), bem como alguns macetes que serão necessários, em certos casos, para que o obtenhamos o resultado desejado em nossas ordenações. Esses macetes nada mais são do que "Funções Auxiliares", que criaremos para agir em conjunto com o método sort().

     Como é uma regra comum, irei inicialmente simbolizar a usabilidade deste método:

1
 myArray.sort();

    Bem simples né? Agora vamos para as particularidades de sua usabilidade, de acordo com cada tipo de lista (e seus valores) que tenhamos que ordenar.

     2.1 - Aplicações em Valores não-Numéricos (string)

     Veremos aqui uma aplicação básica do método sort() em uma lista de valores não-Numéricos (string), formada por nomes:

1
 myArray = ["anderson", "marcelo", "joao neto", "neto leal", "ale porto"];
2
 // Nossa lista de nomes, inserida em nossa Array
3
 
4
 trace("Antes: "+myArray);
5
 // Retorna: anderson,marcelo,joao neto,neto leal,ale porto
6
 
7
 myArray.sort();
8
 // Testamos o método "sort()"
9
 
10
 trace("Depois: "+myArray);
11
 // Retorna: ale porto,anderson,joao neto,marcelo,neto leal

    Bom, até aqui está tudo normal. Podemos ver que no exemplo acima, ordenamos sem problemas toda nossa lista de nomes.

    Porém, vemos que todos os nomes da lista acima, estão em Minúsculas.

    Já se tivermos palavras com iniciais minúsculas e maiúsculas simultaneamente em nossa lista, nossa organização sairia um pouco "defeituosa"...

    Vejamos:

1
 myArray = ["anderson Arboleya", "Marcelo frias", "Joao neto", "neto Leal", "alê porto"];
2
 trace("Antes: "+myArray);
3
 // Retorna: anderson Arboleya,Marcelo frias,Joao neto,neto Leal,alê porto
4
 
5
 myArray.sort();
6
 
7
 trace("Depois: "+myArray);
8
 // Retorna: Joao neto,Marcelo frias,alê porto,anderson Arboleya,neto Leal

     Podemos observar, no exemplo acima, que a organização deu prioridade para os nomes com iniciais Maiúsculas não é? Mesmo estando alfabeticamente localizados depois, muitos nomes apareceram antes do que deveriam.

    Para entender o porquê dessa "inconveniência", basta dizer que cada letra do alfabeto possui um código específico (code point) e que o método sort() simplesmente organiza cada elemento String baseado em seu valor numérico (do menor para o maior). Logo, esse "problema" do sort() se deve ao fato de que as letras maiúsculas possuem um valor menor que as letras minúsculas. Para maiores informações dos códigos de cada letra do alfabeto, a lista completa de "code points" unicode pode ser acessada por este link: http://www.unicode.org/charts/PDF/U0080.pdf

     Simplificando um pouco tudo isso para evitar que nos aprofundemos demais no assunto, suponhamos somente que: "Sempre as palavras com iniciais MAIÚSCULAS, virão ANTES das palavras com iniciais MINÚSCULAS" (não esqueça que isso acontece porque o "code point" das letras maiúsculas vêm antes daqueles das letras minúsculas).


     Para ilustrar novamente, afim de não deixar dúvidas, vejamos mais este exemplo:

1
 myArray = ["marcelo Frias", "Marcelo frias", "anderson Arboleya", "Anderson arboleya"];
2
 trace("Antes: "+myArray);
3
 // Retorna: marcelo Frias,Marcelo frias,anderson Arboleya,Anderson arboleya
4
 
5
 myArray.sort();
6
 
7
 trace("Depois: "+myArray);
8
 // Retorna: Anderson arboleya,Marcelo frias,anderson Arboleya,marcelo Frias

     Novamente, podemos evidenciar que TODAS palavras (ou neste caso, nomes) com iniciais MAIÚSCULAS tiveram prioridade na organização e ficaram na frente das palavras com iniciais MINÚSCULAS.

     Tendo compreendido a "deficiência" deste método, vamos agora aprender a solucionar este pequeno, porém nem tão superficial assim, empecilho.

     Para isto, criaremos uma "Função Auxiliar", que como a própria denominação já diz, nos auxiliará nesta organização para que obtenhamos o resultado desejado, ou seja, que nos permitirá fazermos organizações em listas com variações de iniciais minúsculas e maiúsculas simultaneamente.

1
 // Nossa Função Auxiliar*
2
 _global.sortStr = function (value1, value2){
3
     return (value2.toLowerCase() < value1.toLowerCase());
4
 }
5
 
6
 myArray = ["marcelo Frias", "Marcelo frias", "anderson Arboleya", "Anderson arboleya"];
7
 trace("Antes: "+myArray);
8
 // Retorna: marcelo Frias,Marcelo frias,anderson Arboleya,Anderson arboleya
9
 
10
 myArray.sort(sortStr);
11
 trace("Depois: "+myArray);
12
 // Retorna: anderson Arboleya,Anderson arboleya,marcelo Frias,Marcelo frias
 
Repare que agora, temos que especificar o nome da função auxiliar, dentro dos parênteses na chamada do método sort().
Ex.: myArray.sort(funcao_auxiliar)
 
*Os créditos desta função pertencem ao meu grande amigo e parceiro de trabalho (e por que não dizer, 'professor' =)) Marcelo Frias, que a cedeu-me gentilmente para que eu pudesse implementar e enriquecer mais este tutorial, a fim de que todos possam dominar tanto o método sort() como também os macetes necessários para que o mesmo funcione corretamente. 

     Agora sim, nossa organização está nos retornando o que realmente desejamos. Isso foi possível devido a esta Função Auxiliar, que criamos acima, aplicada em conjunto com o método sort().

     Não entraremos em detalhes desta função aqui neste tutorial mas, sintetizando e resumindo seu funcionamento, a lógica é bem simples de se entender: "A função transforma todos os valores em minúsculas, os compara e posteriormente os devolve com a devida organização".

     Antes de finalizar o tópico Aplicações em Valores não-Numéricos (string), veremos somente mais um exemplo para elucidar o sucesso de nossa operação, para que todos vejam claramente e possam compreender tudo o que está sendo passado:

1
 _global.sortStr = function (value1, value2){
2
     return (value2.toLowerCase() < value1.toLowerCase());
3
 }
4
 
5
 myArray =["anderson", "Ale Porto", "Marcelo frias", "joao neto", "Neto Leal"];
6
 trace("Antes: "+myArray);
7
 // Retorna: anderson,Ale Porto,Marcelo frias,joao neto,Neto Leal
8
 
9
 myArray.sort(sortStr);
10
 trace("Depois: "+myArray);
11
 // Retorna: Ale Porto,anderson,joao neto,Marcelo frias,Neto Leal

     Vejam que agora, embora existam nomes com iniciais Maiúsculas e Minúsculas, nossa organização foi executada com sucesso, da forma como pretendíamos.

     2.2 - Aplicações em Valores Numéricos (number)

     Agora que já demos uma boa estudada no método sort(), aplicando o mesmo em Arrays com lista de valores não-Numéricos (string), veremos sua aplicação em listas de valores Numéricos (number).

     Para iniciar, vejamos o seguinte exemplo:

1
 myArray = [5, 2 ,8 ,4 ,6 ,9 ,5];
2
 trace("Antes: "+myArray);
3
 // Retorna: 5,2,8,4,6,9,5
4
 
5
 myArray.sort();
6
 trace("Depois: "+myArray);
7
 // Retorna: 2,4,5,5,6,8,9

     Já podemos ver logo de cara, no exemplo acima, que o método sort() também funciona perfeitamente com algarismos, ou seja, com uma lista de valores Numéricos (number).

     Porém assim como vimos em Aplicações em Valores não-Numéricos (string), há uma pequena deficiência no método, mas desta vez, relacionada a algarismos.
     Essa deficiência se dá no momento em que nem todos os valores desta nossa lista, nem todos os algarismos, possuem a mesma quantidade de algarismos.

     Vejamos um exemplo:

1
 myArray = [5, 2, 6, 4, 10, 1, 2, 20, 3, 40];
2
 trace("Antes: "+myArray);
3
 // Retorna: 5,2,6,4,10,1,2,20,3,40
4
 
5
 myArray.sort();
6
 trace("Depois: "+myArray);
7
 // Retorna: 1,10,2,2,20,3,4,40,5,6

     Podemos observar no exemplo acima que a organização se deu de forma defeituosa.

     O motivo disto é o fato de que cada valor, cada posição de nossa array, contém um número diferente de caracteres e a ordenação é feita a partir do primeiro algarismo de cada item numérico (repare que 10 -dez- vem antes de 2 -dois-, simplesmente porque o primeiro algarismo do numeral 10 -no caso, 1- é menor que o primeiro algarismo do segundo numeral -no caso, 2-).

    
Para contornar este problema, precisamos, da mesma forma como fizemos em Aplicações em Valores não-Numéricos (string), usar uma Função Auxiliar. Porém, não poderemos utilizar a mesma, pois a anterior era pra valores não-Numéricos (string) e, aqui precisamos de uma específica para valores Númericos (number).

    Então, faremos uma pequena adaptação na Função Auxiliar que criamos anteriormente, e assim criaremos nossa 2º Função Auxiliar.

1
 // Nossa 2º função auxiliar
2
 _global.sortNum = function (value1, value2){
3
     return (value2< value1);
4
  };
5
 
6
 myArray =[5, 2 ,6 ,4 ,10 ,1 ,2 ,20, 3, 40];
7
 trace("Antes: "+myArray);
8
  // Retorna: 5,2,6,4,10,1,2,20,3,40
9
 
10
 myArray.sort(sortNum);
11
  trace("Depois: "+myArray);
12 // Retorna: 1,2,2,3,4,5,6,10,20,40

     Mais uma vez, vimos que para que obtenhamos o resultado desejado em listas de valores Numéricos (number), temos também que nos utilizar de uma Função Auxiliar, que não é a mesma para valores não-Numéricos (string), para que o método esteja completo e a organização se dê por completo e com sucesso.

     Otimização

     Como já pudemos observar até aqui, para que o método sort() funcione corretamente, precisamos criar Funções Auxiliares para agir juntamente com ele.

     Vimos também que necessitamos de uma Função Auxiliar específica para cada tipo de lista que formos organizar:

 Listas de valores Números (number) - sort(sortNum)
1
 // Utilizamos a Função Auxiliar "sortNum"
2
 // Exemplo
3
 myArray.sort(sortNum)

 Listas de valores não-Números (string) - sort(sortStr)
1
 // Utilizamos a Função Auxiliar "sortStr"
2
 // Exemplo
3
 myArray.sort(sortStr)

     Desta forma, conseguiremos fazer nossas organizações corretamente.

     Porém, não seria mais fácil (e menos complicado) se tivéssemos uma só função que servisse tanto para valores numéricos (number) como para valores não-Numéricos   (string) ?

     _ Pois é, é isto que iremos fazer agora:

     Agora, em vez de termos duas funções: sortNum e sortStr:

 1) function sortStr()
1
 _global.sortStr = function(value1, value2) {
2
     return (value2.toLowerCase() < value1.toLowerCase());
3
 };

 2) function sortNum()
1
 _global.sortNum = function(value1, value2) {
2
      return (value2 < value1);
3
 };

     Teremos somente uma, que chamaremos de sortAux:

 function sortAux()
1
 _global.sortAux = function(value1, value2) {
2
      value1 = typeof value1 == 'string' ? value1.toLowerCase() : (value1);
3
      value2 = typeof value2 == 'string' ? value2.toLowerCase() : (value2);
4
      return (value2 < value1);
5
 };

     Mais uma vez, não vamos nos aprofundar na explicação desta função, senão que somente comentar o mais básico, o que provavelmente já dará a você leitor, caso já tenha um pouco de conhecimento em AS, a compreensão de como otimizamos as outras duas funções, numa só, nesta função sortAux().

     A única coisa que fizemos foi fazer uma checagem nos elementos:

     - Caso o elemento seja do tipo não-Numérico (string), o deixamos TODO minúsculo, caso contrário, ou seja, caso seja um valor Numérico (number), não fazemos nada; senão que somente retornamos sua organização.

     Desta forma, agora podemos utilizar a mesma função auxiliar para valores Numéricos (number) e não-Numéricos (string).

     Para finalizar, seguem mais dois exemplos de usabilidade, utilizando esta última Função bi-funcional que criamos, a sortAux():

 Ex. 01) Aplicação em Valores não-Numéricos (string)
1
 myArray = ["anderson","Ale Porto","Marcelo frias","joao neto","Neto Leal"]
2
 trace("Antes: "+myArray);
3
 // Retorna: anderson,Ale Porto,Marcelo frias,joao neto,Neto Leal
4
 
5
 myArray.sort(sortAux)
6
 
7
 trace("Antes: "+myArray);
8
 // Retorna: Ale Porto,anderson,joao neto,Marcelo frias,Neto Leal

   Ex. 02) Aplicação em Valores Numéricos (number)
1
 myArray = [5, 2, 6, 4, 10, 1, 2, 20, 3, 40]
2
 trace("Antes: "+myArray);
3
 // Retorna: 5,2,6,4,10,1,2,20,3,40
4
 
5
 myArray.sort(sortAux)
6
 
7
 trace("Antes: "+myArray);
8
 // Retorna: 1,2,2,3,4,5,6,10,20,40


     :: Notas ::

     - Veja que em ambos exemplos, só utilizamos uma função integrada ao método sort(), a função sortAux().

     - Lembre-se também que para os dois exemplos acima, e para toda sua aplicação, deve-se colocar a função sortAux() no 1º frame do filme.


    
Dicas Úteis

     Até aqui, aprendemos como organizar vários tipos de listas de dados em Arrays; porém, todas as organizações foram Crescentes, tanto nas listas de valores Numéricos (number) como nas listas de valores não-Numéricos (string).

     Porém, é possível que obtenhamos ainda, uma ordenação decrescente.

     Para isto, utilizaremos um outro método do Objeto Array, que é o reverse().

     Como o próprio nome já diz, o método reverse() reverte todos os valores de uma Array. Seria com um dar "flip" em nossa array. A primeira posição passa a ser a última e a última a primeira; a segunda posição passa a ser a penúltima e a penúltima a segunda; e assim por diante...

     Este método é bem simples de se usar, veremos agora dois exemplos de como utilizá-lo, interagindo com a função que criamos - sortAux() - e com o método sort().

1
 // Antes, estavamos utilizandos somente assim
2
 myArray.sort(sortAux)
3
 
4
 // Agora, acrescentaremos ao final da expressão, o método reverse(). Vejamos:
5
 myArray.sort(sortAux).reverse()
 * Este exemplo vale tanto para valores Numéricos como para valores não-Numéricos.

     Considerações Finais

     Neste Tutorial, vimos a utilidade do Método sort() assim como suas deficiências - por assim dizer - , e também as formas de contorná-las.

     Vimos também a utilidade do método reverse(), e como aplicá-lo em conjunto com o método sort().

     Agora, pode ser que você esteja se perguntando:

     "_Seria possível organizar valores Numéricos (number) e não-Númericos (string) simultaneamente, numa mesma lista, numa Array?

     Bem..., sim, seria possível, porém não vejo muita utilidade numa organização como esta.     

    Todavia, deixarei aqui uma solução pronta que criei, para o caso de alguém precisar de uma funcionalidade com esta.

     Esta função serve para organizar listas de valores mistos em Arrays, ou seja, listas que contenham valores Numéricos (number) e nao-Numéricos (string) simultaneamente.

     Ela organiza todos os valores de sua Array, separando antes os valores Numéricos (já organizados) e depois os valores não-Numéricos (também já organizados), e/ou vice-versa, deixando ainda você optar por sua ordem: crescente ou decrescente.

 

 function uniSort()
1
 Array.prototype.uniSort = function(first, rev) {
2
     var  _num=[], _str=[], _op=[];
3
     for (i=this.length; i--; )
4
          if (typeof this[i] == 'number') _num.push(this[i]);
5
          else _str.push(this[i]);
6
     _num.sort(sortAux), _str.sort(sortAux);
7
      if (!rev) _num.reverse(), _str.reverse();
8
      if(first == "string") _op.push(_str,_num);
9
      else _op.push(_num,_str);
10
      return _op.join(",").split(",");
11
 };

     Para utilizá-la, basta seguir o exemplo abaixo:

1
 myArray.uniSort(first, rev)
 
      ## first ##
      Especificamos aqui, a ordem que queremos que venham os valores, ou seja:
           - Se queremos que os valores numéricos venham antes, colocamos "number";
           - Caso contrário, se queremos que os valores não-numéricos venham antes, colocamos "string";

 * Ambas especificações - "string" ou "number" - devem ser setadas, cercadas por ("") aspas.
 
      ## rev ##
      Especificamos aqui, o tipo de ordem que queremos para a organização: Crescente ou Descrescente;
           - Para ordem crescente, utilizamos true;
           - Para ordem decrescente, utilizamos false;

           -> Este parâmetro é opcional e, caso não seja passado, o Default/Padrão é TRUE, ou seja, Crescente;
                Ex.: myArray = myArray.uniSort("number") // ou "string"

 * Ambas especificações - true ou false - devem ser setadas normalmente sem aspas ("").

     Exemplos de Possibilidades de Uso

1
 // Organizamos a Array de modo crescente e a ordenamos de
2
 // forma que os valores não-Numéricos apareçam primeiro
3
 myArray =  myArray.uniSort("string",true)
4
 
5
 // Organizamos a Array de modo decrescente e a ordenamos de
6
 // forma que os valores não-Numéricos apareçam primeiro
7
 myArray =  myArray.uniSort("string",false)
8
 
9
 // Organizamos a Array de modo crescente e a ordenamos de
10
 // forma que os valores Numéricos apareçam primeiro
11
 myArray = myArray.uniSort("number",true)
12
 
13
 // Organizamos a Array de modo decrescente e a ordenamos de
14
 // forma que os valores Numéricos apareçam primeiro
15
 myArray = myArray.uniSort("number",false)
 * Para utilizarmos esta função, uniSort(), temos que ter também a função sortAux() que criamos, em nossa timeLine.
 
 E lembre-se: _Ambas devem estar no 1º frame do filme (preferencialmente).
 
     A função pode ainda, ser chamada sem que nenhum parâmetro seja passado junto a ela. Neste caso, o  padrão da organização será:

           - Valores Numéricos (number) em primeiro lugar; e...
           - Valores não-Numéricos (string) em segundo;
           *Todos com Ordem Crescente.

 Neste caso, a chamada ficaria da seguinte forma:
1
 myArray = myArray.uniSort()


Devido à reformulação implementada no site, pode ser que você encontre alguns links quebrados. Por favor, ajude-nos a corrigir eventuais problemas nos informando links quebrados
2 comentários


Comentário de Marco
| 23/5/2012 - 16:47 |


Anderson, parabens. muito bem explicado. Mas me deparei com um problema eu tenho o array que me retorna o seguinte: Nome:Augusto; indice: 4 Nome:Francisco; indice 1 Nome: Bernardo; indice 10 preciso que me retorne organizado pelo indice Nome:Francisco; indice: 1 Nome:Augusto; indice: 4 Nome: Bernardo; indice: 10



Comentário de jemerson
| 26/5/2011 - 10:20 |


Ola Anderson Arboleya Cara ótimo tutorial tava a algum tempo procurando esse material... mas cara essa função _global.sortNum = function (value1, value2){ return (value2< value1); }; esta dando error na janela "compiler erros" apontando a linha da função.... o que pode ser??? abrass