Collection · 4D Documentation

A classe Collection gerencia variáveis de tipo Collection.

Uma coleção se inicializa com:


New collection {( ...value : any )} : Collection cria uma nova coleção vazia ou pré-completada
New shared collection {( ...value : any )} : Collection cria uma nova coleção vazia ou pré-preenchida partilhada

Exemplo

 var $colVar : Collection //criação de uma variável 4D de tipo coleção
 $colVar:=New collection //initialização da coleção e atribuição à variável 4D

Resumo


.average( {propertyPath : Text } ) : Real retorna a média aritmética de valores definidos da instância da collection
.clear() : Collection remove todos os elementos da instância collection e retorna uma collection vazia
.combine( col2 : Collection {; index : Integer } ) : Collection insere elementos col2 no final da posição especificada index na instância da coleção e retorna a coleção editada
.concat( value : any { ;...valueN } ) : Collection retorna uma nova coleção contendo os elementos da coleção original com todos os elementos do parâmetro value adicionado ao final
.copy() : Collection .copy( option : Integer ) : Collection .copy( option : Integer ; groupWithCol : Collection ) : Collection .copy( option : Integer ; groupWithObj : Object ) : Collection retorna uma cópia profunda da instância collection
.count( { propertyPath : Text } ) : Real retorna o número de elementos não-null na coleção
.countValues( value : any {; propertyPath : Text } ) : Real retorna o número de vezes que o valor foi encontrado na coleção
.distinct( {option : Integer} ) : Collection .distinct( propertyPath : Text {; option : Integer } ) : Collection retorna uma coleção que contém apenas valores distintos (diferentes) da coleção original
.equal( collection2 : Collection {; option : Integer } ) : Boolean compara collection com collection2
.every( methodName : Text { ;...param : any } ) : Boolean .every( startFrom : Integer ; methodName : Text { ;...param : any } ) : Boolean retorna true se todos os elementos na coleção passarem com sucesso o teste implementado no método fornecido methodName
.extract( propertyPath : Text { ; option : Integer } ) : Collection .extract( propertyPath : Text ; targetPath : Text { ;...propertyPathN : Text ;... targetPathN : Text } ) : Collection cria e retorna uma nova coleção contendo valores propertyPath extraídos da coleção original de objetos
.fill( value : any ) : Collection .fill( value : any ; startFrom : Integer { ; end : Integer } ) : Collection retorna a coleção com o value especificado, opcionalmente do índicestartFrom até o índice end, e retorna a coleção resultante
.filter( methodName : Text { ; ...param : any } ) : Collection retorna uma nova coleção contendo todos os elementos da coleção original para a qual o resultado do método methodNamefor true
.find( methodName : Text { ; ...param : any } ) : any .find( startFrom : Integer ; methodName : Text { ; ...param : any } ) : any retorna o primeiro valor na coleção para o qual methodName, aplicado para cada elemento, retorna true
.findIndex( methodName : Text { ; ...param : any } ) : Integer .findIndex( startFrom : Integer ; methodName : Text { ; ...param : any } ) : Integer retorna o índice na coleção do primeiro valor para o qual methodName, aplicado em cada elemento, retorna true
.indexOf( toSearch : expression { ; startFrom : Integer } ) : Integer pesquisa a expressão toSearch entre os elementos da coleção e retorna o índice da primeira ocorrência encontrada, ou -1 se não for encontrado
.indices( queryString : Text { ; ...value : any } ) : Collection retorna indices na coleção original, de elementos coleção objeto que correspondem às queryString condições de pesquisa
.insert( index : Integer ; element : any ) : Collection insere element na posição especificada index na instância da coleção e retorna a coleção editada
.join( delimiter : Text { ; option : Integer } ) : Text converte todos os elementos da coleção para strings e concatena-os usando a string especificada delimiter como um separador
.lastIndexOf( toSearch : expression { ; startFrom : Integer } ) : Integer pesquisa a expressão toSearch entre os elementos da coleção e retorna o índice da primeira ocorrência
.length : Integer retorna o número de elementos na coleção
.map( methodName : Text { ; ...param : any } ) : Collection cria uma nova coleção baseada no resultado da chamada do método methodName de cada elemento da coleção original
.max( { propertyPath : Text } ) : any retorna o elemento com o maior valor na coleção
.min( { propertyPath : Text } ) : any retorna o elemento com o menor valor na coleção
.orderBy( ) : Collection .orderBy( pathStrings : Text ) : Collection .orderBy( pathObjects : Collection ) : Collection .orderBy( ascOrDesc : Integer ) : Collection devolve uma nova coleção que contém todos os elementos da coleção na ordem especificado
.orderByMethod( methodName : Text { ; ...extraParam : expression } ) : Collection devolve uma nova coleção que contém todos os elementos da coleção na ordem definida através do método methodName.

Esta função devolve uma cópia superficial, o que significa que os objetos ou coleções de ambas coleções compartem a mesma referência. Na coleção original é uma coleção partilhada, a coleção retornada também é uma coleção partilhada.

Em methodName, passe um método de comparação que compare dois valores e devolva true em $1.result se o primeiro valor for menor que o segundo. Pode fornecer parâmetros adicionais a methodName se for necessário.

methodName recebe os parâmetros abaixo:
- $1 (objeto), onde:
  - em $1.value (qualquer tipo): primeiro elemento a ser comparado
  - em $1.value2 (qualquer tipo): segundo elemento a ser comparado
- $2...$N (qualquer tipo): parâmetros adicionais
methodName estabelece os parâmetros abaixo:
- $1.result (boolean): true se $1.value < $1.value2, false do contrário

Exemplo 1

Se quiser ordenar a coleção de strings em ordem numérica ao invés de ordem alfabética:

 var $c; $c2; $c3 : Collection
 $c:=New collection
 $c.push("33";"4";"1111";"222")
 $c2:=$c.orderBy() //$c2=["1111","222","33","4"], alphabetical order
 $c3:=$c.orderByMethod("NumAscending") // $c3=["4","33","222","1111"]

O código para NumAscending é:

 $1.result:=Num($1.value)<Num($1.value2)

Exemplo 2

Se quiser ordenar a coleção de strings de acordo com seu tamanho:

 var $fruits; $c2 : Collection
 $fruits:=New collection("Orange";"Apple";"Grape";"pear";"Banana";"fig";"Blackberry";"Passion fruit")
 $c2:=$fruits.orderByMethod("WordLength")
  //$c2=[Passion fruit,Blackberry,Orange,Banana,Apple,Grape,pear,fig]

O código para WordLength é:

 $1.result:=Length(String($1.value))>Length(String($1.value2))

Exemplo 3

Se quiser ordenar a coleção por código de caractere ou alfabeticamente:

var $strings1; $strings2 : Collection
$strings1:=New collection("Alpha";"Charlie";"alpha";"bravo";"Bravo";"charlie")

//usar o código de caractere:
$strings2:=$strings1.orderByMethod("sortCollection";sk character codes)
// result : ["Alpha","Bravo","Charlie","alpha","bravo","charlie"]

//usar a linguagem:
$strings2:=$string1s.orderByMethod("sortCollection";sk strict)
// resultado: ["alpha","Alpha","bravo","Bravo","charlie","Charlie"]

Aqui está o método sortCollection:

var$1Object
var$2Integer // sort option

$1.result:=(Compare strings($1.value;$1.value2;$2)<0)
```|
| [**.pop()** : any](#pop)<p>&nbsp;&nbsp;&nbsp;&nbsp;|
| [**.push**( *element* : any { ;...*elementN* } ) : Collection](#push)<p>&nbsp;&nbsp;&nbsp;&nbsp;adiciona um ou mais *elementos* ao final da instância da coleção e devolve a coleção editada|
| [**.query**( *queryString* : Text ; *...value* : any ) : Collection<br>**.query**( *queryString* : Text ; *querySettings* : Object ) : Collection](#query)<p>&nbsp;&nbsp;&nbsp;&nbsp;devolve todos os elementos de uma coleção de objetos que coincidem com as condiciones de pesquisa|
| [**.reduce**( *methodName* : Text ) : any <br>**.reduce**( *methodName* : Text ; *initValue* : any { ; *...param* : expression } ) : any](#reduce)<p>&nbsp;&nbsp;&nbsp;&nbsp;|
| [**.remove**( *index* : Integer { ; *howMany* : Integer } ) : Collection](#remove)<p>&nbsp;&nbsp;&nbsp;&nbsp;removes one or more element(s) from the specified *index* position in the collection and returns the edited collection|
| [**.resize**( *size* : Integer { ; *defaultValue* : any } ) : Collection](#resize)<p>&nbsp;&nbsp;&nbsp;&nbsp;sets the collection length to the specified new size and returns the resized collection|
| [**.reverse( )** : Collection](#reverse)<p>&nbsp;&nbsp;&nbsp;&nbsp;returns a deep copy of the collection with all its elements in reverse order|
| [**.shift()** : any](#shift)<p>&nbsp;&nbsp;&nbsp;&nbsp;removes the first element of the collection and returns it as the function result|
| [**.slice**( *startFrom* : Integer { ; *end* : Integer } ) : Collection](#slice)<p>&nbsp;&nbsp;&nbsp;&nbsp;returns a portion of a collection into a new collection|
| [**.some**( *methodName* : Text { ; *...param* : any } ) : Boolean<br>**.some**( *startFrom* : Integer ; *methodName* : Text { ; *...param* : any } ) : Boolean](#some)<p>&nbsp;&nbsp;&nbsp;&nbsp;returns true if at least one element in the collection successfully passed a test|
| [**.sort**( *methodName* : Text { ; *...extraParam* : any } ) : Collection](#sort)<p>&nbsp;&nbsp;&nbsp;&nbsp;sorts the elements of the original collection|
| [**.sum**( { *propertyPath* : Text } ) : Real](#sum)<p>&nbsp;&nbsp;&nbsp;&nbsp;returns the sum for all values in the collection instance|
| [**.unshift**( *value* : any { ;...*valueN* : any } ) : Collection](#unshift)<p>&nbsp;&nbsp;&nbsp;&nbsp;inserts the given *value*(s) at the beginning of the collection|



## `Nova coleção`


**New collection** {( *...value* : any )} : Collection
| Parâmetros | Tipo                                                                    |    | Descrição               |
| ---------- | ----------------------------------------------------------------------- |:--:| ----------------------- |
| value      | Number, Text, Date, Time, Boolean, Object, Collection, Picture, Pointer | -> | Valor(es) de collection |
| Resultado  | Collection                                                              | <- | Nova coleção            |


#### Descrição

O comando `Nova coleção`  cria uma nova coleção vazia ou pré-completada e devolve sua referência.

Se não passar nenhum parâmetro, `New collection` cria uma coleção vazia e retorna sua referência.

Precisa atribuir a referência devolvida à uma variável 4D de tipo Collection.
> Lembre que as declarações `var : Collection` ou `C_COLLECTION` declaram uma variável do tipo `Collection` mas não criam novas coleções.

Opcionalmente pode pré-preencher a nova coleção passando um ou mais parâmetros *value*.

Pode também adicionar ou modificar elementos subsequentemente através de assignação. Por exemplo:

```4d
 myCol[10]:="My new element"

Se o novo índice de elemento estiver além do último elemento existente da coleção, a coelção é redimensionada automaticamente e todos os elementos intermediários são atribuídos ao valor null.

Pode passar qualquer número de valores de qualquer tipo compatível (número, texto, data, imagem, ponteiro, objeto, coleção....). Diferente de arrays, coleções podem misturar dados de tipos diferentes.

Pode prestar atenção aos problemas de conversão abaixo:

Se passar um ponteiro, é mantido "tal qual": é avaliado usando o comando JSON Stringify
Datas são armazenadas no formato "aaaa-mm-dd" ou strings com o formato "AAAA-MM-DDTHH:mm:ss.SSSZ", de acordo com a configuração atual "dates inside objects"/datas dentro de objetos. Quando converter datas 4D em texto antes de armazená-las em uma coleção, como padrão o programa considera a zona horária local. Pode modificar esse comportamento usando o seletor Dates inside objects do comando SET DATABASE PARAMETER.
Se passar a hora, é armazenada como um número de milissegundos (Real).

Exemplo 1

Se quiser criar uma nova coleção vazia e atribuí-la à uma variável coleção 4D:

 var $myCol : Collection
 $myCol:=New collection
  //$myCol=[]

Exemplo 2

Se quiser criar uma coleção pré-prenchida:

 var $filledColl : Collection
 $filledColl:=New collection(33;"mike";"november";->myPtr;Current date)
  //$filledColl=[33,"mike","november","->myPtr","2017-03-28T22:00:00.000Z"]

Exemplo 3

Pode criar uma nova coleção e adicionar um novo elemento:

 var $coll : Collection
 $coll:=New collection("a";"b";"c")
  //$coll=["a","b","c"]
 $coll[9]:="z" //add a 10th element with value "z"
 $vcolSize:=$coll.length //10
  //$coll=["a","b","c",null,null,null,null,null,null,"z"]

`Nova coleção partilhada`

Histórico

Versão	Mudanças
v16 R6	Adicionada

New shared collection {( ...value : any )} : Collection

Parâmetros	Tipo		Descrição
value	Number, Text, Date, Time, Boolean, Shared object, Shared collection	->	Valores da collection compartida
Resultado	Collection	<-	Nova collection compartida

Descrição

O comando New shared collection cria uma nova coleção vazia ou pré-preenchida partilhada e retorna sua referência.

Adicionar um elemento para essa coleção deve ser rodeada pela estrutura Use...End, senão um erro é gerado. Ler um elemento sem a estrutura é entretanto possível.

Se não quiser passar parâmetros, New shared collection cria uma coleção vazia partilhada e retorna sua referência.

Precisa atribuir a referência devolvida à uma variável 4D de tipo Collection.

Opcionalmente pode preencher automaticamente a nova coleção partilhada passando um ou vários valorescomo parâmetros. Também pode adicionar ou modificar elementos através de atribuição de notação de objetos (ver exemplo).

Se o novo índice elemento for além do último elemento existente da coleção partilhada, a coleção é automaticamente redimensionada e todos os novos elementos intermediários são atribuídos um valornull.

Pode passar qualquer número de valores dos tipos compatíveis abaixo:

número (real, longint....). Valores numéricos são sempre armazenados como reais.
text
booleano
data
hora (armazenada como número de milissegundos - real)
null
objeto compartido(*)
collection compartida(*)

(*)Quando um objeto partilhado ou coleção forem adicionadas a uma coleção partilhada, partilham o mesmo locking identifier. Para saber mais sobre esse ponto, veja o guia 4D Developer'.

Exemplo

 $mySharedCol:=New shared collection("alpha";"omega")
 Use($mySharedCol)
    $mySharedCol[1]:="beta"
 End use

.average()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.average( {propertyPath : Text } ) : Real

Parâmetros	Tipo		Descrição
propertyPath	Texto	->	Rota de propriedade objeto a ser usado para cálculos
Resultado	Real, Undefined	<-	Média aritmética dos valores coleção

Descrição

A função .average() retorna a média aritmética de valores definidos da instância da collection.

Apenas elementos numéricos são considerados para cálculos (outros tipos são ignorados).

Se a coleção contiver objetos, passe o parâmetro propertyPath para indicar a propriedade objeto para levar em consideração.

.average() retorna undefined se:

a coleção estiver vazia,
a coleção não contiver elementos numéricos,
propertyPath não for encontrada na collection.

Exemplo 1

 var $col : Collection
 $col:=New collection(10;20;"Monday";True;6)
 $vAvg:=$col.average() //12

Exemplo 2

 var $col : Collection
 $col:=New collection
 $col.push(New object("name";"Smith";"salary";10000))
 $col.push(New object("name";"Wesson";"salary";50000))
 $col.push(New object("name";"Gross";"salary";10500))
 $vAvg:=$col.average("salary") //23500

.clear()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.clear() : Collection

Parâmetros	Tipo		Descrição
Resultado	Collection	<-	Collection original com todos os elementos removidos

Descrição

A função .clear() remove todos os elementos da instância collection e retorna uma collection vazia.

Exemplo

var $col : Collection
$col:=New collection(1;2;5)
$col.clear()
$vSize:=$col.length //$vSize=0

.combine()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.combine( col2 : Collection {; index : Integer } ) : Collection

Parâmetros	Tipo		Descrição
col2	Collection	->	Collection a combinar
index	Integer	->	Posição para a qual inserir elementos para combinar em coleção (padrão = length +1)
Resultado	Collection	<-	Collection original contendo elementos combinados

Descrição

A função .combine() insere elementos col2 no final da posição especificada index na instância da coleção e retorna a coleção editada. Diferente da função .insert(), .combine() adiciona cada valor de col2 na collection original, e não como um único elemento da coleção.

Como padrão, elementos col2 são adicionados ao final da collection original. Pode passar em index a posição onde quiser que os elmentos col2 sejam inseridos na coleção.

Se index > o tamanho da coleção, o início real de index será estabelecido para o tamanho da coleção.
Se index < 0, será recalculado como index:=index+length (é considerado como o offset do final da coleção).
Se o valor calculado for negativo, index será estabelecido como 0.

Exemplo

var $c; $fruits : Collection
$c:=New collection(1;2;3;4;5;6)
$fruits:=New collection("Orange";"Banana";"Apple";"Grape")
$c.combine($fruits;3) //[1,2,3,"Orange","Banana","Apple","Grape",4,5,6]

.concat()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.concat( value : any { ;...valueN } ) : Collection

Parâmetros	Tipo		Descrição
value	Number, Text, Object, Collection, Date, Time, Boolean, Picture	->	Valores a concatenar. Se value for uma coleção, todos os elementos da coleção são adicionados para a coleção original
Resultado	Collection	<-	Nova coleção com valores adicionados à coleção original

Descrição

A função .concat() retorna uma nova coleção contendo os elementos da coleção original com todos os elementos do parâmetro value adicionado ao final.

Se value for uma coleção, todos os elementos são adicionados como novos elementos no final da coleção original. Se value não for a coleção, será adicionado ao novo elemento.

Exemplo

var $c : Collection
$c:=New collection(1;2;3;4;5)
$fruits:=New collection("Orange";"Banana";"Apple";"Grape")
$fruits.push(New object("Intruder";"Tomato"))
$c2:=$c.concat($fruits) //[1,2,3,4,5,"Orange","Banana","Apple","Grape",{"Intruder":"Tomato"}]
$c2:=$c.concat(6;7;8) //[1,2,3,4,5,6,7,8]

.copy()

Histórico

Versão	Mudanças
v18 R3	New ck shared option. New groupWith parameters
v16 R6	Adicionado

.copy() : Collection
.copy( option : Integer ) : Collection
.copy( option : Integer ; groupWithCol : Collection ) : Collection
.copy( option : Integer ; groupWithObj : Object ) : Collection

Parâmetros	Tipo		Descrição
option	Integer	->	`ck resolve pointers`: resolve ponteiros antes de copiar, `ck shared`: retorna uma coleção partilihada
groupWithCol	Collection	->	Coleção partilhada a ser agrupada com a coleção resultante
groupWithObj	Objeto	->	Objeto partilhado a ser agrupado com a coleção resultante
Resultado	Collection	<-	Cópia profunda da collection original

Descrição

A função .copy() retorna uma cópia profunda da instância collection.Deep copy significa que objetos ou collections dentro da coleção original são duplicadas e não partilham qualquer referência com a collection retornada.

Se passado, o parâmetro option pode conter uma das constantes abaixo (ou ambas):

option	Descrição
`ck resolve pointers`	Se a collection original contém valores tipo ponteiro, por padrão a cópia também contém os ponteiros. Entretanto pode resolver ponteiros quando copiar por passando os ck resolve pointers. Nesse caso, cada ponteiro presenta na coleção é avaliada quando copiar e seu valor de dereferencia é usado.
`ck shared`	Como padrão, copy() retorna uma colleciton regular (não partilhado), mesmo se o comando for aplicado para a collection shared. Passe a constante ck shared para criar uma collection shared. Nesse caso, pode usar o parâmetro groupWith para associar a collection partilhada com outra collection ou objeto (ver abaixo).

Os parâmetros groupWithCol ou groupWithObj permite determinar uma collection ou um objeto com o qual a coleção resultante deveria ser associada.

Exemplo 1

Se quiser copiar a collection comum (não partilhada) $lastnames no objeto partilhado $sharedObject. Para fazer isso, precisa criar uma cópia partilhada da coleção ($sharedLastnames).

var $sharedObject : Object
var $lastnames;$sharedLastnames : Collection
var $text : Text

$sharedObject:=New shared object

$text:=Document to text(Get 4D folder(Current resources folder)+"lastnames.txt")
$lastnames:=JSON Parse($text) //$lastnames é uma collection regular

$sharedLastnames:=$lastnames.copy(ck shared) //$sharedLastnames é uma collection partilhada

//Agora podemos colocar $sharedLastnames em $sharedObject
Use($sharedObject)
    $sharedObject.lastnames:=$sharedLastnames
End use

Exemplo 2

Se quisermos combinar $sharedColl1 e $sharedColl2. Já que pertencem a grupos partilhados diferentes, uma combinação diferente resultaria em um erro. Por isso precisa fazer uma cópia partilhada de $sharedColl1 e designar $sharedColl2 commo um grupo partilhado para a cópia.

var $sharedColl1;$sharedColl2;$copyColl : Collection

$sharedColl1:=New shared collection(New shared object("lastname";"Smith"))
$sharedColl2:=New shared collection(New shared object("lastname";"Brown"))

//$copyColl belongs to the same shared group as $sharedColl2
 $copyColl:=$sharedColl1.copy(ck shared;$sharedColl2)
 Use($sharedColl2)
    $sharedColl2.combine($copyColl)
 End use

Exemplo 3

Se tiver uma collection comum ($lastnames) e se quisermos colocar emStorage da aplicação. Para fazer isso, precisamos criar antes uma cópia partilhada ($sharedLastnames).

var $lastnames;$sharedLastnames : Collection
var $text : Text

$text:=Document to text(Get 4D folder(Current resources folder)+"lastnames.txt")
$lastnames:=JSON Parse($text) //$lastnames é uma collection normal

$sharedLastnames:=$lastnames.copy(ck shared) //cópia partilhada

Use(Storage)
    Storage.lastnames:=$sharedLastnames
End use

Exemplo 4

Esse exemplo ilustra o uso da opção ck resolve pointers:

 var $col : Collection
 var $p : Pointer
 $p:=->$what

 $col:=New collection
 $col.push(New object("alpha";"Hello";"num";1))
 $col.push(New object("beta";"You";"what";$p))

 $col2:=$col.copy()
 $col2[1].beta:="World!"
 ALERT($col[0].alpha+" "+$col2[1].beta) //exibe "Hello World!"

 $what:="You!"
 $col3:=$col2.copy(ck resolve pointers)
 ALERT($col3[0].alpha+" "+$col3[1].what) //exibe "Hello You!"

.count()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.count( { propertyPath : Text } ) : Real

Parâmetros	Tipo		Descrição
propertyPath	Texto	->	Rota de propriedade objeto a ser usado para cálculos
Resultado	Real	<-	Número de elementos na coleção

Descrição

A função .count() retorna o número de elementos não-null na coleção.

Se a coleção conter objetos, pode passar o parâmetro propertyPath. Nesse caso, só elementos que conterem propertyPath serão levados em consideração.

Exemplo

 var $col : Collection
 var $count1;$count2 : Real
 $col:=New collection(20;30;Null;40)
 $col.push(New object("name";"Smith";"salary";10000))
 $col.push(New object("name";"Wesson";"salary";50000))
 $col.push(New object("name";"Gross";"salary";10500))
 $col.push(New object("lastName";"Henry";"salary";12000))
 $count1:=$col.count() //$count1=7
 $count2:=$col.count("name") //$count2=3

.countValues()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.countValues( value : any {; propertyPath : Text } ) : Real

Parâmetros	Tipo		Descrição
value	Text, Number, Boolean, Date, Object, Collection	->	Valor a contar
propertyPath	Texto	->	Rota de propriedade objeto a ser usado para cálculos
Resultado	Real	<-	Número de ocorrências do valor

Descrição

A função .countValues() retorna o número de vezes que o valor foi encontrado na coleção.

Pode passar em value:

um valor escalar (texto, número, booleano, data),
um objeto ou uma referência de coleção.

Para um elemento ser encontrado, o tipo de value deve ser equivalente ao tipo de elemento, o método usa o operador equality.

O parâmetro opcional propertyPath permite contar valores dentro de uma coleção de objetos: passe em propertyPath a rota da propriedade cujos valores quer contar.

Exemplo 1

 var $col : Collection
 var $vCount : Integer
 $col:=New collection(1;2;5;5;5;3;6;4)
 $vCount:=$col.countValues(5) // $vCount=3

Exemplo 2

 var $col : Collection
 var $vCount : Integer
 $col:=New collection
 $col.push(New object("name";"Smith";"age";5))
 $col.push(New object("name";"Wesson";"age";2))
 $col.push(New object("name";"Jones";"age";3))
 $col.push(New object("name";"Henry";"age";4))
 $col.push(New object("name";"Gross";"age";5))
 $vCount:=$col.countValues(5;"age") //$vCount=2

Exemplo 3

 var $numbers; $letters : Collection
 var $vCount : Integer

 $letters:=New collection("a";"b";"c")
 $numbers:=New collection(1;2;$letters;3;4;5)

 $vCount:=$numbers.countValues($letters) //$vCount=1

.distinct()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.distinct( {option : Integer} ) : Collection
.distinct( propertyPath : Text {; option : Integer } ) : Collection

Parâmetros	Tipo		Descrição
option	Integer	->	`ck diacritical`: avaliação diacríticos ("A" # "a" por exemplo)
propertyPath	Texto	->	Rota do atributo cujos valores quer obter
Resultado	Collection	<-	Nova coleção com apenas valores distintos

Descrição

A função .distinct() function retorna uma coleção que contém apenas valores distintos (diferentes) da coleção original.

A coleção retornada é ordenada automaticamente. Valores Null não são retornados.

Como padrão, uma avaliação não-diacrítica é realizada. Se quiser que a avaliação diferencie minúsculas de maiúsculas ou que diferencie letras acentuadas, passe a constante ck diacritical no parâmetrooption.

Se a coleção conter objetos, pode passar o parâmetro propertyPath para indicar a propriedade objeto cujos valores diferentes você quer obter.

Example

 var $c; $c2 : Collection
 $c:=New collection
 $c.push("a";"b";"c";"A";"B";"c";"b";"b")
 $c.push(New object("size";1))
 $c.push(New object("size";3))
 $c.push(New object("size";1))
 $c2:=$c.distinct() //$c2=["a","b","c",{"size":1},{"size":3},{"size":1}]
 $c2:=$c.distinct(ck diacritical) //$c2=["a","A","b","B","c",{"size":1},{"size":3},{"size":1}]
 $c2:=$c.distinct("size") //$c2=[1,3]

.equal()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.equal( collection2 : Collection {; option : Integer } ) : Boolean

Parâmetros	Tipo		Descrição
collection2	Collection	->	Coleção a comparar
option	Integer	->	`ck diacritical`: avaliação diacríticos ("A" # "a" por exemplo)
Resultado	Booleano	<-	True se as coleções forem idênticas, senão false

Descrição

A função .equal() compara collection com collection2 e retorna true se forem idênticos (comparação profunda/deep comparison).

Como padrão, uma avaliação não-diacrítica é realizada. Se quiser que a avaliação diferencie maiúsculas de minúsculas e caracteres acentuados, passe a constanteck diacritical no parâmetro option.

Exemplo

 var $c; $c2 : Collection
 var $b : Boolean

 $c:=New collection(New object("a";1;"b";"orange");2;3)
 $c2:=New collection(New object("a";1;"b";"orange");2;3;4)
 $b:=$c.equal($c2) // false

 $c:=New collection(New object("1";"a";"b";"orange");2;3)
 $c2:=New collection(New object("a";1;"b";"orange");2;3)
 $b:=$c.equal($c2) // false

 $c:=New collection(New object("a";1;"b";"orange");2;3)
 $c2:=New collection(New object("a";1;"b";"ORange");2;3)
 $b:=$c.equal($c2) // true

 $c:=New collection(New object("a";1;"b";"orange");2;3)
 $c2:=New collection(New object("a";1;"b";"ORange");2;3)
 $b:=$c.equal($c2;ck diacritical) //false

.every()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.every( methodName : Text { ;...param : any } ) : Boolean
.every( startFrom : Integer ; methodName : Text { ;...param : any } ) : Boolean

Parâmetros	Tipo		Descrição
startFrom	Integer	->	Índice para início do teste em
methodName	Texto	->	Nome do método para chamar para o teste
param	Mixed	->	Parâmetros a passar para methodName
Resultados	Booleano	<-	True se todos os elementos passarem o teste com sucesso

Descrição

A função .every() retorna true se todos os elementos na coleção passarem com sucesso o teste implementado no método fornecido methodName.

Em methodName, passe o nome do método para usar para avliar elementos collection, junto com os parâmetros em param (opcional). methodName pode realizar qualquer teste, com ou sem os parâmetros. can perform any test, with or without the parameter(s). Esse método recebe um Object no primeiro parâmetro($1) e deve estabelecer o $1.result como true para todo elemento que cumpre o teste.

methodName recebe os parâmetros abaixo:

em $1.value: valor elemento a ser avaliado
$2: param
$N: paramN...

methodName estabelece os parâmetros abaixo:

$1.result (Booleano): true se a avaliação do elemento valor tiver sucesso, senão seráfalse.
$1.stop (Booleano, opcional): true para parar o método callback. O valor retornado é o último calculado.

Em todos os casos, no ponto quanod a função .every() encontra o primeiro elemento de coleção retornando false em $1.result, ele para de chamar methodName e retorna false.

Como padrão, .every() testa a coleção completa. Opcionalmente pode passar em startFrom o índice do elemento do qual vai começar o teste.

Se startFrom >= tamanho da coleção, é retornado false, o que significa que a coleção não é testada.
Se startFrom < 0, é considerada como offset do final da coleção( startFrom:=startFrom+length).
Se startFrom = 0, a coleção inteira é pesquisada (padrão).

Exemplo 1

var $c : Collection  
var $b : Boolean
$c:=New collection
$c.push(5;3;1;4;6;2)
$b:=$c.every("NumberGreaterThan0") //retorna true
$c.push(-1)
$b:=$c.every("NumberGreaterThan0") //retorna false

Com o método a seguir NumberGreaterThan0:

$1.result:=$1.value>0

Exemplo 2

Esse exemplo testa que todos os elementos da coleção sejam do tipo real:

var $c : Collection
var $b : Boolean
$c:=New collection
$c.push(5;3;1;4;6;2)
$b:=$c.every("TypeLookUp";Is real) //$b=true
$c:=$c.push(New object("name";"Cleveland";"zc";35049))
$c:=$c.push(New object("name";"Blountsville";"zc";35031))
$b:=$c.every("TypeLookUp";Is real) //$b=false

Com o método TypeLookUp:

#DECLARE ($toEval : Object ; $param : Integer) //$1; $2
If(Value type($toEval.value)=$param)
    $toEval.result:=True
End if

.extract()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.extract( propertyPath : Text { ; option : Integer } ) : Collection
.extract( propertyPath : Text ; targetPath : Text { ;...propertyPathN : Text ;... targetPathN : Text } ) : Collection

Parâmetros	Tipo		Descrição
propertyPath	Texto	->	Rota de propriedade de objeto cujos valores serão extraídos para nova coleção
targetpath	Texto	->	Rota de propriedade alvo ou nome propriedade
option	Inteiro	->	`ck keep null`: inclui propriedades null na coleção retornada (ignorado como padrão). Parâmetro ignorado se for passado targetPath.
Resultados	Collection	<-	Nova collection contendo valores extraídos

Descrição

A função .extract() cria e retorna uma nova coleção contendo valores propertyPath extraídos da coleção original de objetos.

Os conteúdos da coleção retornada depende do parâmetro targetPath:

Se o parâmetro targetPath for omitido, .extract() preenche a nova coleção com os valores propertyPath da coleção original.

Como padrão, elementos para os quais propertyPath for null ou undefined são ignorados na coleção resultante. Pode passar a constante ck keep null no parâmetro option para incluir esses valores como elementos null na coleção retornada.

Se um ou mais parâmetros targetPath forem passados,, .extract() preenche a nova coelção com as propriedades propertyPath e cada elemento da nova coleção é um objeto com as propriedades targetPath preenchidas com as propriedades correspondentes propertyPath. Valores null são mantidos (o parâmetro option é ignorado com essa sintaxe).

Exemplo 1

var $c : Collection
$c:=New collection
$c.push(New object("name";"Cleveland"))
$c.push(New object("zip";5321))
$c.push(New object("name";"Blountsville"))
$c.push(42)
$c2:=$c.extract("name") // $c2=[Cleveland,Blountsville]
$c2:=$c.extract("name";ck keep null) //$c2=[Cleveland,null,Blountsville,null]

Exemplo 2

var $c : Collection
$c:=New collection
$c.push(New object("zc";35060))
$c.push(New object("name";Null;"zc";35049))
$c.push(New object("name";"Cleveland";"zc";35049))
$c.push(New object("name";"Blountsville";"zc";35031))
$c.push(New object("name";"Adger";"zc";35006))
$c.push(New object("name";"Clanton";"zc";35046))
$c.push(New object("name";"Clanton";"zc";35045))
$c2:=$c.extract("name";"City") //$c2=[{City:null},{City:Cleveland},{City:Blountsville},{City:Adger},{City:Clanton},{City:Clanton}]
$c2:=$c.extract("name";"City";"zc";"Zip") //$c2=[{Zip:35060},{City:null,Zip:35049},{City:Cleveland,Zip:35049},{City:Blountsville,Zip:35031},{City:Adger,Zip:35006},{City:Clanton,Zip:35046},{City:Clanton,Zip:35045}]

.fill()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.fill( value : any ) : Collection
.fill( value : any ; startFrom : Integer { ; end : Integer } ) : Collection

Parâmetros	Tipo		Descrição
value	number, Text, Collection, Object, Date, Boolean	->	Valores preenchido
startFrom	Integer	->	Início do índice (incluído)
end	Integer	->	Final do índice (não incluído)
Resultados	coleção	<-	Coleção original com valores preenchidos

Descrição

A função .fill() retorna a coleção com o value especificado, opcionalmente do índicestartFrom até o índice end, e retorna a coleção resultante.

Se o parâmetro startFrom for omitido, value é estabelecido para todos os elementos coleção (startFrom=0).
Se o parâmetro startFrom for passado e o parâmetroend for omitido, value é estabelecido para elementos de coleção começando com startFrom até o elemento final da coleção (end=length).
Se tanto startFrom quanto end forem passados, value é estabelecido para elementos coleção começando em startFrom ao elemento end.

Em caso de inconsistências, as regras abaixos são seguidas:

Se index < 0, será recalculado como startFrom:=startFrom+length (é considerado como o offset do final da coleção). Se o valor calculado for negativo, startFrom toma o valor 0.
Se end < 0 , é recalculado como sendo end:=end+length.
Se end < startFrom (valores passados ou calculados), o método não faz nada.

Exemplo

 var $c : Collection
 $c:=New collection(1;2;3;"Lemon";Null;"";4;5)
 $c.fill("2") // $c:=[2,2,2,2,2,2,2,2]
 $c.fill("Hello";5) // $c=[2,2,2,2,2,Hello,Hello,Hello]
 $c.fill(0;1;5) // $c=[2,0,0,0,0,Hello,Hello,Hello]
 $c.fill("world";1;-5) //-5+8=3 -> $c=[2,"world","world",0,0,Hello,Hello,Hello]

.filter()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.filter( methodName : Text { ; ...param : any } ) : Collection

Parâmetros	Tipo		Descrição
methodName	Texto	->	Nome da função a chamar para filtrar a coleção
param	Mixed	->	Parâmetros a passar para methodName
Resultados	Collection	<-	Nova coleção contendo elementos filtrados (cópia superficial)

Descrição

A função .filter() retorna uma nova coleção contendo todos os elementos da coleção original para a qual o resultado do método methodNamefor true. Essa função retorna uma shallow copy/cópia superficial, o que significa que objetos ou coleções em ambas as coleções partilham a mesma referência. Na coleção original é uma coleção partilhada, a coleção retornada também é uma coleção partilhada.

Em methodName, passe o nome do método para usar para avliar elementos collection, junto com os parâmetros em param (opcional). methodName pode realizar qualquer teste, com ou sem os parâmetros. Esse método recebe um Objeto no primeiro parâmetro ($1) e deve estabelecer $1.result como true para cada elemento que preenche a condição e assim, enviado para a nova coleção.

methodName recebe os parâmetros abaixo:

em $1.value: valor elemento a ser filtrado
em $2: param
$N...: param2...paramN

methodName estabelece os parâmetros abaixo:

$1.result (boolean): true se o valor elemento corresponder à condição de filtro e tiver que ser mantido.
$1.stop (boolean, opcional): true para parar o callback do método. O valor retornado é o último calculado.

Exemplo 1

Se quiser obter a coleção de elementos textos cujo tamanho for menor que 6:

 var $col;$colNew : Collection
 $col:=New collection("hello";"world";"red horse";66;"tim";"san jose";"miami")
 $colNew:=$col.filter("LengthLessThan";6)
  //$colNew=["hello","world","tim","miami"]

O código para o método LengthLessThan é:

 C_OBJECT($1)
 C_LONGINT($2)
 If(Value type($1.value)=Is text)
    $1.result:=(Length($1.value))<$2
 End if

Exemplo 2

Se quiser filtrar elementos de acordo com seu tipo de valor:

 var $c;$c2;$c3 : Collection
 $c:=New collection(5;3;1;4;6;2)
 $c.push(New object("name";"Cleveland";"zc";35049))
 $c.push(New object("name";"Blountsville";"zc";35031))
 $c2:=$c.filter("TypeLookUp";Is real) // $c2=[5,3,1,4,6,2]
 $c3:=$c.filter("TypeLookUp";Is object)
  // $c3=[{name:Cleveland,zc:35049},{name:Blountsville,zc:35031}]

O código para TypeLookUp é:

 C_OBJECT($1)
 C_LONGINT($2)
 If(OB Get type($1;"value")=$2)


    $1.result:=True
 End if

.find()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.find( methodName : Text { ; ...param : any } ) : any
.find( startFrom : Integer ; methodName : Text { ; ...param : any } ) : any

Parâmetros	Tipo		Descrição
startFrom	Integer	->	Índice onde inicia a pesquisa
methodName	Texto	->	Nome da função a chamar para o find
param	any	->	Parâmetros a passar para methodName
Resultado	any	<-	Primeiro valor encontrado ou Undefined se não encontrado

Descrição

A função .find() retorna o primeiro valor na coleção para o qual methodName, aplicado para cada elemento, retorna true.

Em methodName, passe o nome do método para usar para avliar elementos collection, junto com os parâmetros em param (opcional). methodName pode realizar qualquer teste, com ou sem os parâmetros. can perform any test, with or without the parameter(s). Esse método recebe um Objeto no primeiro parâmetro ($1) e deve estabelecer $1.result como true para o primeiro elemento que preenche a condição.

methodName recebe os parâmetros abaixo:

em $1.value: valor do elemento a avaliar
in $2: param
$N...: param2...paramN

methodName estabelece os parâmetros abaixo:

$1.result (boolean): true se o valor elemento corresponder à condição de pesquisa.
$1.stop (boolean, opcional): true para parar o callback do método. O valor retornado é o último calculado.

Como padrão, .every() testa a coleção completa. Opcionalmente pode passar em startFrom o índice do elemento a partir do qual vai começar a pesquisa.

Se startFrom >= tamanho da coleção, é retornado false, o que significa que a coleção não é pesquisada.
Se startFrom < 0, é considerada como offset do final da coleção (startFrom:=startFrom+length). Nota: Mesmo se startFrom for negativo, a coleção ainda é pesquisada da esquerda para direita.
Se startFrom = 0, a coleção inteira é pesquisada (padrão).

Exemplo 1

Se quiser obter o primeiro elemento com um tamanho menor que 5:

 var $col : Collection
 $col:=New collection("hello";"world";4;"red horse";"tim";"san jose")
 $value:=$col.find("LengthLessThan";5) //$value="tim"

O código para o método LengthLessThan é:

 var $1 : Object
 var $2 : Integer
 If(Value type($1.value)=Is text)
    $1.result:=(Length($1.value))<$2
 End if

Exemplo 2

Se quiser encontrar o nome da cidade dentro da coleção:

 var $c; $c2 : Collection
 $c:=New collection
 $c.push(New object("name";"Cleveland";"zc";35049))
 $c.push(New object("name";"Blountsville";"zc";35031))
 $c.push(New object("name";"Adger";"zc";35006))
 $c.push(New object("name";"Clanton";"zc";35046))
 $c.push(New object("name";"Clanton";"zc";35045))
 $c2:=$c.find("FindCity";"Clanton") //$c2={name:Clanton,zc:35046}

O código para TypeLookUp é:

 var $1 : Object
 var $2 : Text
 $1.result:=$1.value.name=$2 //nome  é um nome de propriedade de objetos na coleção

.findIndex()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.findIndex( methodName : Text { ; ...param : any } ) : Integer
.findIndex( startFrom : Integer ; methodName : Text { ; ...param : any } ) : Integer

Parâmetros	Tipo		Descrição
startFrom	Integer	->	Índice onde inicia a pesquisa
methodName	Texto	->	Nome da função a chamar para o find
param	any	->	Parâmetros a passar para methodName
Resultados	Integer	<-	Indice do primeiro valor encontrado ou -1 se não encontrado

Descrição

The .findIndex() function retorna o índice na coleção do primeiro valor para o qual methodName, aplicado em cada elemento, retorna true.

Em methodName, passe o nome do método para usar para avliar elementos collection, junto com os parâmetros em param (opcional). methodName pode realizar qualquer teste, com ou sem os parâmetros. Este método recebe um Object como primeiro parâmetro ($1) e deve estabelecer $1.result para true para o primeiro elemento que cumprir a condição.

methodName recebe os parâmetros abaixo:

em $1.value: valor elemento a ser avaliado
in $2: param
$N...: param2...paramN

methodName estabelece os parâmetros abaixo:

$1.result (boolean): true se o valor elemento corresponder à condição de pesquisa.
$1.stop (boolean, opcional): true para parar o callback do método. O valor retornado é o último calculado.

Como padrão, .findIndex() testa a coleção completa. Opcionalmente pode passar em startFrom o índice do elemento a partir do qual vai começar a pesquisa.

Se startFrom >= tamanho da coleção, é retornado false, o que significa que a coleção não é pesquisada.
Se startFrom < 0, é considerada como offset do final da coleção (startFrom:=startFrom+length). Nota: Mesmo se startFrom for negativo, a coleção ainda é pesquisada da esquerda para direita.
Se startFrom = 0, a coleção inteira é pesquisada (padrão).

Exemplo

Se quiser encontrar a posição do primeiro nome de cidade dentro da coleção:

 var $c : Collection
 var $val2;$val3 : Integer
 $c:=New collection
 $c.push(New object("name";"Cleveland";"zc";35049))
 $c.push(New object("name";"Blountsville";"zc";35031))
 $c.push(New object("name";"Adger";"zc";35006))
 $c.push(New object("name";"Clanton";"zc";35046))
 $c.push(New object("name";"Clanton";"zc";35045))
 $val2:=$c.findIndex("FindCity";"Clanton") // $val2=3
 $val3:=$c.findIndex($val2+1;"FindCity";"Clanton") //$val3=4

O código para o método FindCity é:

 var $1 : Object
 var $2 : Text
 $1.result:=$1.value.name=$2

.indexOf()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.indexOf( toSearch : expression { ; startFrom : Integer } ) : Integer

Parâmetros	Tipo		Descrição
toSearch	expressão	->	Expressão a pesquisar na coleção
startFrom	Integer	->	Índice onde inicia a pesquisa
Resultados	Integer	<-	Índice da primeira ocorrência de toSearch na coleção, -1 se não encontrado

Descrição

A função.indexOf() pesquisa a expressão toSearch entre os elementos da coleção e retorna o índice da primeira ocorrência encontrada, ou -1 se não for encontrado.

Em toSearch, passe a expressão para encontrar na coleção. Pode passar:

um valor escalar (texto, número, booleano, data),
o valor null,
um objeto ou uma referência de coleção.

toSearch deve corresponder exatamente com o elemento a encontrar (as mesmas regras que para o operador de igualdade do tipo dados é aplicado).

Opcionalmente pode passar o índice da coleção para a qual iniciar a pesquisa emstartFrom.

Se startFrom >= tamanho da coleção, é retornado false, o que significa que a coleção não é pesquisada.
Se startFrom < 0, é considerada como offset do final da coleção (startFrom:=startFrom+length). Nota: Mesmo se startFrom for negativo, a coleção ainda é pesquisada da esquerda para direita.
Se startFrom = 0, a coleção inteira é pesquisada (padrão).

Exemplo

 var $col : Collection
 var $i : Integer
 $col:=New collection(1;2;"Henry";5;3;"Albert";6;4;"Alan";5)
 $i:=$col.indexOf(3) //$i=4
 $i:=$col.indexOf(5;5) //$i=9
 $i:=$col.indexOf("al@") //$i=5
 $i:=$col.indexOf("Hello") //$i=-1

.indices()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.indices( queryString : Text { ; ...value : any } ) : Collection

Parâmetros	Tipo		Descrição
queryString	Texto	->	Critérios de pesquisa
value	any	->	Valores a comparar quando usar placeholders (valores temporários)
Resultado	Collection	<-	Índices elemento correspondendo a queryString na coleção

Descrição

A função .indices() trabalha exatamente da mesma forma que a função .query() mas retorna indices na coleção original, de elementos coleção objeto que correspondem às queryString condições de pesquisa, e não os elementos em si mesmo. Indices são retornados em ordem ascendente.

O parâmetro queryString usa a sintaxe abaixo:

valor de comparação propertyPath {valor de comparação logicalOperator propertyPath}

Para uma descrição detalhada dos parâmetros queryString e value, veja a função dataClass.query().

Exemplo

 var $c; $icol : Collection
 $c:=New collection
 $c.push(New object("name";"Cleveland";"zc";35049))
 $c.push(New object("name";"Blountsville";"zc";35031))

 $c.push(New object("name";"Adger";"zc";35006))
 $c.push(New object("name";"Clanton";"zc";35046))
 $c.push(New object("name";"Clanton";"zc";35045))
 $icol:=$c.indices("name = :1";"Cleveland") // $icol=[0]
 $icol:=$c.indices("zc > 35040") // $icol=[0,3,4]

.insert()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.insert( index : Integer ; element : any ) : Collection

Parâmetros	Tipo		Descrição
index	Integer	->	Onde inserir os elementos
element	any	->	Elemento a inserir na coleção
Resultado	Collection	<-	Collection original contendo elementos inseridos

Descrição

A função .insert() insere element na posição especificada index na instância da coleção e retorna a coleção editada.

In index, passe a posição onde quiser que o elemento seja inserido na coleção.

Se index > o tamanho da coleção, o índice de início é estabelecido como o tamanho da coleção.
Se index < 0, será recalculado como index:=index+length (é considerado como o offset do final da coleção).
Se o valor calculado for negativo, index será estabelecido como 0.

Qualquer tipo de elemento aceito por uma coleção pode ser inserido, mesmo outra coleção.

Exemplo

 var $col : Collection
 $col:=New collection("a";"b";"c";"d") //$col=["a","b","c","d"]
 $col.insert(2;"X") //$col=["a","b","X","c","d"]
 $col.insert(-2;"Y") //$col=["a","b","X","Y","c","d"]
 $col.insert(-10;"Hi") //$col=["Hi","a","b","X","Y","c","d"]

.join()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.join( delimiter : Text { ; option : Integer } ) : Text

Parâmetros	Tipo		Descrição
delimiter	Texto	->	Separador a usar entre os elementos
option	Integer	->	`ck ignore null or empty`: ignora strings vazias ou nulls no resultado
Resultados	Texto	<-	String contendo todos os elementos da coleção, separados por um delimitador

Descrição

a função .join() converte todos os elementos da coleção para strings e concatena-os usando a string especificada delimiter como um separador. A função retorna a string resultado.

Como padrão, elementos null ou vazios da coleção são retornados na string resultante. Passe a constante ck ignore null or empty na opção option parâmetro se quiser removê-las da string resultado.

Exemplo

 var $c : Collection
 var $t1;$t2 : Text
 $c:=New collection(1;2;3;"Paris";Null;"";4;5)
 $t1:=$c.join("|") //1|2|3|Paris|null||4|5
 $t2:=$c.join("|";ck ignore null or empty) //1|2|3|Paris|4|5

.lastIndexOf()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.lastIndexOf( toSearch : expression { ; startFrom : Integer } ) : Integer

Parâmetros	Tipo		Descrição
toSearch	expressão	->	O elemento que é pesquisado dentro da coleção
startFrom	Integer	->	Índice onde inicia a pesquisa
Resultados	Integer	<-	Índice da última ocorrência de toSearch na coleção, -1 se não encontrado

Descrição

A função.lastIndexOf() pesquisa a expressão toSearch entre os elementos da coleção e retorna o índice da primeira ocorrência, ou -1 se não for encontrado

Em toSearch, passe a expressão para encontrar na coleção. Pode passar:

um valor escalar (texto, número, booleano, data),
o valor null,
um objeto ou uma referência de coleção.

toSearch deve corresponder exatamente com o elemento a encontrar (as mesmas regras que para o operador de igualdade é aplicado).

Opcionalmente pode passar o índice da coleção para a qual iniciar a pesquisa reversa em startFrom.

Se startFrom >= o tamanho da coleção menos um (coll.length-1), a coleção inteira é pesquisada (padrão).
Se index < 0, será recalculado como startFrom:=startFrom+length (é considerado como o offset do final da coleção). Se o valor calculado for negativo, -1 é retornado (a coleção não é pesquisada). Nota: Mesmo se startFrom for negativo, a coleção ainda é pesquisada da direita para esquerda.
Se startFrom = 0, é retornado -1, o que significa que a coleção não é pesquisada.

Exemplo

 var $col : Collection
 var $pos1;$pos2;$pos3;$pos4;$pos5 : Integer 
 $col:=Split string("a,b,c,d,e,f,g,h,i,j,e,k,e";",") //$col.length=13
 $pos1:=$col.lastIndexOf("e") //returns 12
 $pos2:=$col.lastIndexOf("e";6) //returns 4
 $pos3:=$col.lastIndexOf("e";15) //returns 12
 $pos4:=$col.lastIndexOf("e";-2) //returns 10
 $pos5:=$col.lastIndexOf("x") //returns -1

.length

Histórico

Versão	Mudanças
v16 R5	Adicionado

.length : Integer

Descrição

A propriedade .length retorna o número de elementos na coleção.

A propriedade .length é iniciada quando a coleção for criada. Adicionar ou remover elementos atualiza o tamanho, se necessário. Essa propriedade é read-only /apenas leitura (não pode usá-la para estabelecer o tamanho da coleção).

Exemplo

 var $col : Collection //$col.length inicializa em 0
 $col:=New collection("one";"two";"three") //$col.length atualizado a  3
 $col[4]:="five" //$col.length atualizado a 5
 $vSize:=$col.remove(0;3).length //$vSize=2

.map()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.map( methodName : Text { ; ...param : any } ) : Collection

Parâmetros	Tipo		Descrição
methodName	Texto	->	Nome do método usado para transformar os elementos da coleção
param	any	->	Parâmetros para o método
Resultado	Collection	<-	Collection de valores transformados

Descrição

A função .map() cria uma nova coleção baseada no resultado da chamada do método methodName de cada elemento da coleção original. Opcionalmente pode passar parâmetros amethodName usando os parâmetros param. .map() sempre retorna uma coleção com o mesmo tamanho que a coleção original.

Em methodName, passe o nome do método para usar para avliar elementos collection, junto com os parâmetros em param (opcional). methodName pode realizar qualquer operação, com ou sem os parâmetros.

methodName recebe os parâmetros abaixo:

em $1.value (qualquer tipo): valor elemento a ser avaliado
em $2(qualquer tipo): param
em $N...(qualquer tipo): paramN...

methodName estabelece os parâmetros abaixo:

$1.result (qualquer tipo): novo valor transformado para adicionar à coleção resultante
$1.stop (boolean): true para parar o callback do método. O valor retornado é o último calculado.

Exemplo

 var $c; $c2 : Collection
 $c:=New collection(1;4;9;10;20)
 $c2:=$c.map("Percentage";$c.sum())
  //$c2=[2.27,9.09,20.45,22.73,45.45]

Aqui está o método Percentage:

 var $1 : Object
 var $2 : Real
 $1.result:=Round(($1.value/$2)*100;2)

.max()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.max( { propertyPath : Text } ) : any

Parâmetros	Tipo		Descrição
propertyPath	Texto	->	Rota de propriedade objeto a ser usado para avaliação
Resultado	Boolean, Text, Number, Collection, Object, Date	<-	Valor máximo na coleção

Descrição

A função .max() retorna o elemento com o maior valor na coleção (o último elemento da coleção como seria ordenado de forma ascendente usando a função .sort()).

Se a coleção conter diferentes tipos de valores, a função .max() devolverá o valor máximo dentro do último tipo de elemento na orde, da lista de tipos (ver a descrição de .sort()).

Se a coleção conter objetos, pode passar o parâmetro propertyPath para indicar a propriedade objeto cujos valores máximos você quer obter.

Se a coleção estiver vazia, .max() devolve Undefined.

Exemplo

 var $col : Collection
 $col:=New collection(200;150;55)
 $col.push(New object("name";"Smith";"salary";10000))
 $col.push(New object("name";"Wesson";"salary";50000))
 $col.push(New object("name";"Alabama";"salary";10500))
 $max:=$col.max() //{name:Alabama,salary:10500}
 $maxSal:=$col.max("salary") //50000
 $maxName:=$col.max("name") //"Wesson"

.min()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.min( { propertyPath : Text } ) : any

Parâmetros	Tipo		Descrição
propertyPath	Texto	->	Rota de propriedade objeto a ser usado para avaliação
Resultados	Boolean, Text, Number, Collection, Object, Date	<-	Valor mínimo na coleção

Descrição

A função .min() retorna o elemento com o menor valor na coleção (o primeiro elemento da coleção como seria ordenado de forma ascendente usando a função .sort()).

Se a coleção conter diferentes tipos de valores, a função .min() devolverá o valor mínimo dentro do primeiro tipo de elemento na ordem da lista de tipos (ver a descrição de .sort()).

Se a coleção conter objetos, pode passar o parâmetro propertyPath para indicar a propriedade objeto cujos valores mínimos você quer obter.

Se a coleção estiver vazia, .min() devolve Undefined.

Exemplo

 var $col : Collection
 $col:=New collection(200;150;55)
 $col.push(New object("name";"Smith";"salary";10000))
 $col.push(New object("name";"Wesson";"salary";50000))
 $col.push(New object("name";"Alabama";"salary";10500))
 $min:=$col.min() //55
 $minSal:=$col.min("salary") //10000
 $minName:=$col.min("name") //"Alabama"

.orderBy()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.orderBy( ) : Collection
.orderBy( pathStrings : Text ) : Collection
.orderBy( pathObjects : Collection ) : Collection
.orderBy( ascOrDesc : Integer ) : Collection

Parâmetros	Tipo		Descrição
pathStrings	Texto	->	Property path(s) on which to order the collection
pathObjects	Collection	->	Collection of criteria objects
ascOrDesc	Integer	->	`ck ascending` or `ck descending` (scalar values)
Result	Collection	<-	Ordered copy of the collection (shallow copy)

Descrição

A função .orderBy() devolve uma nova coleção que contém todos os elementos da coleção na ordem especificado.

Se não passar nenhum parâmetro, a função ordena os valores escalares da coleção em ordem ascendente (outros tipos de elementos, como objetos ou coleções, se devolvem desordenados). Pode modificar esta ordem automático passando as constantes ck ascending ou ck descending no parâmetro ascOrDesc (ver abaixo).

Também pode passar um parâmetro de critérios para definir como devem ordenar-se os elementos da coleção. Três sintaxes são compatíveis com esse parâmetro:

pathStrings : Text (fórmula). Syntax: propertyPath1 {desc or asc}, propertyPath2 {desc or asc},... (default order: asc). pathStrings contém uma fórmula composta de 1 a x rotas de propriedades e (opcionalmente) ordens de classificação, separados por vírgulas. A ordem na qual as propriedades são passadas determina a prioridade de ordenação dos elementos da coleção Como padrão as propriedades são ordenadas de forma ascendente. Pode definir a ordem de clasificação de uma propriedade na string de critérios, separado da rota da propriedade por um só espaço: passe "asc" para ordenar em ordem ascendente ou "desc" em ordem descendente.
pathObjects : Collection. Pode adicionar tantos objetos na coleção pathObjects como seja necessário. Como padrão, as propriedades se classificam em ordem ascendente ("descending" é false). Cada elemento da coleção contém um objeto estruturado da seguinte maneira:

{
    "propertyPath": string,
    "descending": boolean
}

ascOrDesc: Integer. Se passar uma das seguintes constantes do tema Objects and collections:

Constante Tipo Valor Comentário

ck ascending Inteiro longo 0 Os elementos são ordenados de forma ascendente (por padrão)

ck descending Longint 1 Os elementos são ordenados de forma descendente

Essa sintaxe ordena apenas os valores escalares da coleção (outros tipos de elementos como objetos ou coleções são retornados sem ordenar).

Se a coleção conter elementos de tipos diferentes, são primeiro agrupados por tipo e ordenados depois. Tipos são retornados na ordem abaixo:

null
boolean
strings
números
objetos
collections
dates

Exemplo 1

Ordenar uma coleção de números em ordem ascendente e descendente:

 var $c; $c2; $3 : Collection 
 $c:=New collection
 For($vCounter;1;10)
    $c.push(Random)
 End for
 $c2:=$c.orderBy(ck ascending)
 $c3:=$c.orderBy(ck descending)

Exemplo 2

Ordenar uma coleção de objetos a partir de uma fórmula de texto com nomes de propriedades:

 var $c; $c2 : Collection
 $c:=New collection
 For($vCounter;1;10)
    $c.push(New object("id";$vCounter;"value";Random))
 End for
 $c2:=$c.orderBy("value desc")
 $c2:=$c.orderBy("value desc, id")
 $c2:=$c.orderBy("value desc, id asc")

Ordenar uma coleção de objetos com uma rota de propriedades:

 var $c; $c2 : Collection
 $c:=New collection
 $c.push(New object("name";"Cleveland";"phones";New object("p1";"01";"p2";"02")))
 $c.push(New object("name";"Blountsville";"phones";New object("p1";"00";"p2";"03")))

 $c2:=$c.orderBy("phones.p1 asc")

Exemplo 3

Ordenar uma coleção de objetos utilizando uma coleção de objetos critério:

 var $crit; $c; $c2 : COllection
 $crit:=New collection
 $c:=New collection
 For($vCounter;1;10)
    $c.push(New object("id";$vCounter;"value";Random))
 End for
 $crit.push(New object("propertyPath";"value";"descending";True))
 $crit.push(New object("propertyPath";"id";"descending";False))
 $c2:=$c.orderBy($crit)

Ordenar com uma rota de propriedade:

 var $crit; $c; $c2 : Collection
 $c:=New collection
 $c.push(New object("name";"Cleveland";"phones";New object("p1";"01";"p2";"02")))
 $c.push(New object("name";"Blountsville";"phones";New object("p1";"00";"p2";"03")))
 $crit:=New collection(New object("propertyPath";"phones.p2";"descending";True))
 $c2:=$c.orderBy($crit)

.orderByMethod()

Histórico

Versão	Mudanças
v16 R6	Adicionado

.orderByMethod( methodName : Text { ; ...extraParam : expression } ) : Collection

Parameter	Type		Description
methodName	Texto	->	Nome do método utilizado para especificar a ordem de clasificação
extraParam	expressão	->	Parâmetros para o método
Result	Collection	<-	Cópia ordenada da coleção (cópia superficial)

Descrição

A função .orderByMethod() devolve uma nova coleção que contém todos os elementos da coleção na ordem definida através do método methodName.

methodName recebe os parâmetros abaixo:
- $1 (objeto), onde:
  - em $1.value (qualquer tipo): primeiro elemento a ser comparado
  - em $1.value2 (qualquer tipo): segundo elemento a ser comparado
- $2...$N (qualquer tipo): parâmetros adicionais
methodName estabelece os parâmetros abaixo:
- $1.result (boolean): true se $1.value < $1.value2, false do contrário

Exemplo 1

Se quiser ordenar a coleção de strings em ordem numérica ao invés de ordem alfabética:

 var $c; $c2; $c3 : Collection
 $c:=New collection
 $c.push("33";"4";"1111";"222")
 $c2:=$c.orderBy() //$c2=["1111","222","33","4"], alphabetical order
 $c3:=$c.orderByMethod("NumAscending") // $c3=["4","33","222","1111"]

O código para NumAscending é:

 $1.result:=Num($1.value)<Num($1.value2)

Exemplo 2

Se quiser ordenar a coleção de strings de acordo com seu tamanho:

 var $fruits; $c2 : Collection
 $fruits:=New collection("Orange";"Apple";"Grape";"pear";"Banana";"fig";"Blackberry";"Passion fruit")
 $c2:=$fruits.orderByMethod("WordLength")
  //$c2=[Passion fruit,Blackberry,Orange,Banana,Apple,Grape,pear,fig]

O código para WordLength é:

 $1.result:=Length(String($1.value))>Length(String($1.value2))

Exemplo 3

Se quiser ordenar a coleção por código de caractere ou alfabeticamente:

var $strings1; $strings2 : Collection
$strings1:=New collection("Alpha";"Charlie";"alpha";"bravo";"Bravo";"charlie")

//usar o código de caractere:
$strings2:=$strings1.orderByMethod("sortCollection";sk character codes)
// result : ["Alpha","Bravo","Charlie","alpha","bravo","charlie"]

//usar a linguagem:
$strings2:=$string1s.orderByMethod("sortCollection";sk strict)
// resultado: ["alpha","Alpha","bravo","Bravo","charlie","Charlie"]

Aqui está o método sortCollection:

var$1Object
var$2Integer // sort option

$1.result:=(Compare strings($1.value;$1.value2;$2)<0)
```## .pop()

<details><summary>Histórico</summary>
| Versão | Mudanças   |
| ------ | ---------- |
| v16 R6 | Adicionado |
</details>**.pop()** : any| Parameter | Type |    | Description                |
| --------- | ---- |:--:| -------------------------- |
| Result    | any  | <- | Último elemento da coleção |#### Descrição

A função `.pop()`elimina o último elemento da coleção e o devolve como resultado da função.
> Essa função modifica a collection original.

Quando for aplicado a uma coleção vazia, `.pop()` devolve ***undefined***.

#### Exemplo

`.pop()`, utilizado junto com [`.push()`](#push), pode ser utilizado para implementar uma funcionalidade primeira entrada, última saída de tratamento de dados empilhados:

```4d
 var $stack : Collection
 $stack:=New collection //$stack=[]
 $stack.push(1;2) //$stack=[1,2]
 $stack.pop() //$stack=[1]  Returns 2
 $stack.push(New collection(4;5)) //$stack=[[1,[4,5]]
 $stack.pop() //$stack=[1]  Returns [4,5]
 $stack.pop() //$stack=[]  Returns 1
```## .push()

<details><summary>Histórico</summary>
| Versão | Mudanças   |
| ------ | ---------- |
| v16 R6 | Adicionado |
</details>**.push**( *element* : any { ;...*elementN* } ) : Collection| Parameter | Type       |    | Description                                      |
| --------- | ---------- |:--:| ------------------------------------------------ |
| element   | Mixed      | -> | Elementos a adicionar à coleção                  |
| Result    | Collection | <- | Collection original contendo elementos inseridos |#### Descrição

A função `.push()`adiciona um ou mais *elementos* ao final da instância da coleção e devolve a coleção editada.
> Essa função modifica a collection original.


#### Exemplo 1

```4d
 var $col : Collection
 $col:=New collection(1;2) //$col=[1,2]
 $col.push(3) //$col=[1,2,3]
 $col.push(6;New object("firstname";"John";"lastname";"Smith"))
  //$col=[1,2,3,6,{firstname:John,lastname:Smith}

Exemplo 2

Se quiser ordenar a coleção resultante:

 var $col; $sortedCol : Collection
 $col:=New collection(5;3;9) //$col=[5,3,9]
 $sortedCol:=$col.push(7;50).sort()
  //$col=[5,3,9,7,50]
  //$sortedCol=[3,5,7,9,50]
```## .query()

<details><summary>Histórico</summary>
| Versão | Mudanças                     |
| ------ | ---------------------------- |
| v17 R5 | Assistência de querySettings |
| v16 R6 | Adicionado                   |
</details>**.query**( *queryString* : Text ; *...value* : any ) : Collection<br>**.query**( *queryString* : Text ; *querySettings* : Object ) : Collection| Parameter     | Type       |    | Description                                                       |
| ------------- | ---------- |:--:| ----------------------------------------------------------------- |
| queryString   | Texto      | -> | Critérios de pesquisa                                             |
| value         | Mixed      | -> | Valores a comparar quando usar placeholders (valores temporários) |
| querySettings | Objeto     | -> | Opções de pesquisa: parâmetros, atributos                         |
| Result        | Collection | <- | Elementos que correspondem com queryString na coleção             |#### Descrição

A função `.query()`devolve todos os elementos de uma coleção de objetos que coincidem com as condiciones de pesquisadefinidas por *queryString* e (opcionalmente) *value* ou *querySettings*. Na coleção original é uma coleção partilhada, a coleção retornada também é uma coleção partilhada.
> Essa função não modifica a coleção original.

O parâmetro *queryString* usa a sintaxe abaixo:

```4d
valor de comparação propertyPath {valor de comparação logicalOperator propertyPath}

Para obter informação detalhada sobre como construir uma consulta utilizando os parâmetros queryString, value e querySettings, consulte a descrição da função dataClass.query().

Exemplo 1

 var $c; $c2; $c3 : Collection
 $c:=New collection
 $c.push(New object("name";"Cleveland";"zc";35049))
 $c.push(New object("name";"Blountsville";"zc";35031))
 $c.push(New object("name";"Adger";"zc";35006))
 $c.push(New object("name";"Clanton";"zc";35046))
 $c.push(New object("name";"Clanton";"zc";35045))
 $c2:=$c.query("name = :1";"Cleveland") //$c2=[{name:Cleveland,zc:35049}]
 $c3:=$c.query("zc > 35040") //$c3=[{name:Cleveland,zc:35049},{name:Clanton,zc:35046},{name:Clanton,zc:35045}]

Exemplo 2

 var $c : Collection
 $c:=New collection
 $c.push(New object("name";"Smith";"dateHired";!22-05-2002!;"age";45))
 $c.push(New object("name";"Wesson";"dateHired";!30-11-2017!))
 $c.push(New object("name";"Winch";"dateHired";!16-05-2018!;"age";36))

 $c.push(New object("name";"Sterling";"dateHired";!10-5-1999!;"age";Null))
 $c.push(New object("name";"Mark";"dateHired";!01-01-2002!))

Este exemplo devolve as pessoas cujo nome contém "in":

 $col:=$c.query("name = :1";"@in@")
  //$col=[{name:Winch...},{name:Sterling...}]

Este exemplo devolve as pessoas cujo nome não começa por uma string de uma variável (introduzida pelo usuário, por exemplo):

 $col:=$c.query("name # :1";$aString+"@")
  //if $astring="W"
  //$col=[{name:Smith...},{name:Sterling...},{name:Mark...}]

Este exemplo devolve as pessoas cuja idade não se conhece (propriedade definida como null ou indefinida):

 $col:=$c.query("age=null") //não são permitidos placeholders ou marcadores de posição com "null"
  //$col=[{name:Wesson...},{name:Sterling...},{name:Mark...}]

Este exemplo devolve as pessoas contratadas há mais de 90 dias:

 $col:=$c.query("dateHired < :1";(Current date-90))
  //$col=[{name:Smith...},{name:Sterling...},{name:Mark...}] se hoje for 01/10/2018

Exemplo 3

Mais exemplos de pesquisas podem ser encontrados na página dataClass.query(). ## .reduce()

Histórico

Versão	Mudanças
v16 R6	Adicionado
.reduce( methodName : Text ) : any .reduce( methodName : Text ; initValue : any { ; ...param : expression } ) : any	Parameter	Type		Description
----------	-----------------------------------------------	:--:	----------------------------------------------------------------------------
methodName	Texto	->	Nome da função a qual se chama para processar os elementos da coleção
initValue	Text, Number, Object, Collection, Date, Boolean	->	Valor a utilizar como primeiro argumento da primeira chamada de methodName
param	expressão	->	Parâmetros a passar para methodName
Result	Text, Number, Object, Collection, Date, Boolean	<-	Resultado do valor do acumulador	#### Descrição

A função .reduce()aplica o método de retrochamada methodName contra um acumulador e cada elemento da coleção (de esquerda a direita) para reduzi-lo a um único valor.

Em methodName, passe o nome do método para usar para avaliar elementos de coleção, junto com os parâmetros em param (opcional). methodName toma cada elemento da coleção e realiza todas as operações desejadas para acumular o resultado em $1.accumulator, que se devolve em $1.value.

Pode passar o valor para inicializar o acumulador em initValue. Se omitido, $1.accumulator> começa com Undefined.

methodName recebe os parâmetros abaixo:

em $1.value: valor elemento a ser processado
in $2: param
em $N...: paramN...

methodName estabelece os parâmetros abaixo:

$1.accumulator: valor que vai ser modificado pela função e que é inicializado por initValue.
$1.stop (boolean, opcional): true para parar o callback do método. O valor retornado é o último calculado.

Exemplo 1

 C_COLLECTION($c)
 $c:=New collection(5;3;5;1;3;4;4;6;2;2)
 $r:=$c.reduce("Multiply";1) //returns 86400

Com o método Multiply:

 If(Value type($1.value)=Is real)
    $1.accumulator:=$1.accumulator*$1.value
 End if

Exemplo

Este exemplo permite reduzir vários elementos da coleção a um só:

 var $c;$r : Collection
 $c:=New collection
 $c.push(New collection(0;1))
 $c.push(New collection(2;3))
 $c.push(New collection(4;5))
 $c.push(New collection(6;7))
 $r:=$c.reduce("Flatten") //$r=[0,1,2,3,4,5,6,7]

Com o método Flatten:

 If($1.accumulator=Null)
    $1.accumulator:=New collection
 End if
 $1.accumulator.combine($1.value)
```## .remove()

<details><summary>Histórico</summary>
| Versão | Mudanças   |
| ------ | ---------- |
| v16 R6 | Adicionado |
</details>**.remove**( *index* : Integer { ; *howMany* : Integer } ) : Collection| Parameter | Type       |    | Description                                             |
| --------- | ---------- |:--:| ------------------------------------------------------- |
| index     | Integer    | -> | Elemento no qual que se inicia a eliminação             |
| howMany   | Integer    | -> | Número de elementos a eliminar, ou 1 elemento se omitir |
| Result    | Collection | <- | Colección original sem elementos eliminados             |#### Descrição

The `.remove()` functionremoves one or more element(s) from the specified *index* position in the collection and returns the edited collection.
> This function modifies the original collection.

In *index*, pass the position where you want the element to be removed from the collection.
> **Warning**: Keep in mind that collection elements are numbered from 0. If *index* is greater than the length of the collection, actual starting index will be set to the length of the collection.

*   If *index* < 0, it is recalculated as *index:=index+length* (it is considered as the offset from the end of the collection).
*   If the calculated value < 0, *index* is set to 0.
*   If the calculated value > the length of the collection, *index* is set to the length.

In *howMany*, pass the number of elements to remove from *index*. If *howMany* is not specified, then one element is removed.



If you try to remove an element from an empty collection, the method does nothing (no error is generated).


#### Exemplo


```4d
 var $col : Collection
 $col:=New collection("a";"b";"c";"d";"e";"f";"g";"h")
 $col.remove(3) // $col=["a","b","c","e","f","g","h"]
 $col.remove(3;2) // $col=["a","b","c","g","h"]
 $col.remove(-8;1) // $col=["b","c","g","h"]
 $col.remove(-3;1) // $col=["b","g","h"]
```## .resize()


<details><summary>Histórico</summary>
| Versão | Mudanças   |
| ------ | ---------- |
| v16 R6 | Adicionado |
</details>**.resize**( *size* : Integer { ; *defaultValue* : any } ) : Collection| Parameter    | Type                                            |    | Description                        |
| ------------ | ----------------------------------------------- |:--:| ---------------------------------- |
| size         | Integer                                         | -> | New size of the collection         |
| defaultValue | Number, Text, Object, Collection, Date, Boolean | -> | Default value to fill new elements |
| Result       | Collection                                      | <- | Resized original collection        |#### Description

The `.resize()` functionsets the collection length to the specified new size and returns the resized collection.
> This function modifies the original collection.

*   If *size* < collection length, exceeding elements are removed from the collection.
*   If *size* > collection length, the collection length is increased to size.

By default, new elements are filled will **null** values. You can specify the value to fill in added elements using the *defaultValue* parameter.

#### Exemplo


```4d
 var $c : Collection
 $c:=New collection
 $c.resize(10) // $c=[null,null,null,null,null,null,null,null,null,null]

 $c:=New collection
 $c.resize(10;0) // $c=[0,0,0,0,0,0,0,0,0,0]

 $c:=New collection(1;2;3;4;5)
 $c.resize(10;New object("name";"X")) //$c=[1,2,3,4,5,{name:X},{name:X},{name:X},{name:X},{name:X}]

 $c:=New collection(1;2;3;4;5)
 $c.resize(2) //$c=[1,2]

```## .reverse()

<details><summary>Histórico</summary>
| Versão | Mudanças   |
| ------ | ---------- |
| v16 R6 | Adicionado |
</details>**.reverse( )** : Collection| Parameter | Type       |    | Description                     |
| --------- | ---------- |:--:| ------------------------------- |
| Result    | Collection | <- | Inverted copy of the collection |#### Description

The `.reverse()` functionreturns a deep copy of the collection with all its elements in reverse order. Na coleção original é uma coleção partilhada, a coleção retornada também é uma coleção partilhada.
> This function does not modify the original collection.

#### Exemplo


```4d
 var $c; $c2 : Collection
 $c:=New collection(1;3;5;2;4;6)
 $c2:=$c.reverse() //$c2=[6,4,2,5,3,1]
```## .shift()

<details><summary>Histórico</summary>
| Versão | Mudanças   |
| ------ | ---------- |
| v16 R6 | Adicionado |
</details>**.shift()** : any| Parameter | Type |    | Description                 |
| --------- | ---- |:--:| --------------------------- |
| Result    | any  | <- | First element of collection |#### Description

The `.shift()` functionremoves the first element of the collection and returns it as the function result.
> This function modifies the original collection.

If the collection is empty, this method does nothing.

#### Exemplo


```4d
 var $c : Collection
 var $val : Variant
 $c:=New collection(1;2;4;5;6;7;8)
 $val:=$c.shift()
  // $val=1
  // $c=[2,4,5,6,7,8]
```## .slice()

<details><summary>Histórico</summary>
| Versão | Mudanças   |
| ------ | ---------- |
| v16 R6 | Adicionado |
</details>**.slice**( *startFrom* : Integer { ; *end* : Integer } ) : Collection| Parameter | Type       |    | Description                                              |
| --------- | ---------- |:--:| -------------------------------------------------------- |
| startFrom | Integer    | -> | Index to start the search at (included)                  |
| end       | Integer    | -> | Final do índice (não incluído)                           |
| Result    | Collection | <- | New collection containing sliced elements (shallow copy) |#### Description

The `.slice()` functionreturns a portion of a collection into a new collection, selected from *startFrom* index to *end* index (end not included). This function returns a *shallow copy* of the collection. Na coleção original é uma coleção partilhada, a coleção retornada também é uma coleção partilhada.
> This function does not modify the original collection.

The returned collection contains the element specified by *startFrom* and all subsequent elements up to, but not including, the element specified by *end*. If only the *startFrom* parameter is specified, the returned collection contains all elements from *startFrom* to the last element of the original collection.

*   If *startFrom* < 0, it is recalculated as *startFrom:=startFrom+length* (it is considered as the offset from the end of the collection).
*   If the calculated value < 0, *startFrom* is set to 0.
*   If *end* < 0 , it is recalculated as *end:=end+length*.
*   If *end < startFrom* (passed or calculated values), the method does nothing.

#### Exemplo


```4d
 var $c; $nc : Collection
 $c:=New collection(1;2;3;4;5)
 $nc:=$c.slice(0;3) //$nc=[1,2,3]
 $nc:=$c.slice(3) //$nc=[4,5]
 $nc:=$c.slice(1;-1) //$nc=[2,3,4]
 $nc:=$c.slice(-3;-2) //$nc=[3]
```## .some()

<details><summary>Histórico</summary>
| Versão | Mudanças   |
| ------ | ---------- |
| v16 R6 | Adicionado |
</details>**.some**( *methodName* : Text { ; *...param* : any } ) : Boolean<br>**.some**( *startFrom* : Integer ; *methodName* : Text { ; *...param* : any } ) : Boolean| Parameter  | Type     |    | Description                                               |
| ---------- | -------- |:--:| --------------------------------------------------------- |
| startFrom  | Integer  | -> | Índice para início do teste em                            |
| methodName | Texto    | -> | Nome do método para chamar para o teste                   |
| param      | Mixed    | -> | Parâmetros a passar para *methodName*                     |
| Result     | Booleano | <- | True if at least one element successfully passed the test |#### Description

The `.some()` functionreturns true if at least one element in the collection successfully passed a testimplemented in the provided *methodName* method.


Em *methodName*, passe o nome do método para usar para avliar elementos collection, junto com os parâmetros em *param* (opcional). *methodName* pode realizar qualquer teste, com ou sem os parâmetros. can perform any test, with or without the parameter(s). This method receives an `Object` as first parameter ($1) and must set *$1.result* to **True** for every element fulfilling the test.

*methodName* recebe os parâmetros abaixo:

*   in *$1.value*: element value to be evaluated
*   *$2*: param
*   *$N...*: param2...paramN

*methodName* estabelece os parâmetros abaixo:

*   *$1.result* (boolean): **true** if the element value evaluation is successful, **false** otherwise.
*   *$1.stop* (boolean, optional): **true** to stop the method callback. The returned value is the last calculated.

In any case, at the point where `.some()` function encounters the first collection element returning true in *$1.result*, it stops calling *methodName* and returns **true**.

By default, `.some()` tests the whole collection. Optionally, you can pass the index of an element from which to start the test in *startFrom*.

*   If *startFrom* >= the collection's length, **False** is returned, which means the collection is not tested.
*   If *startFrom* < 0, it is considered as the offset from the end of the collection.
*   If *startFrom* = 0, the whole collection is searched (default).


#### Exemplo


```4d
 var $c : Collection
 var $b : Boolean
 $c:=New collection
 $c.push(-5;-3;-1;-4;-6;-2)
 $b:=$c.some("NumberGreaterThan0") // returns false
 $c.push(1)
 $b:=$c.some("NumberGreaterThan0") // returns true

 $c:=New collection
 $c.push(1;-5;-3;-1;-4;-6;-2)
 $b:=$c.some("NumberGreaterThan0") //$b=true
 $b:=$c.some(1;"NumberGreaterThan0") //$b=false

With the following NumberGreaterThan0 method:

 $1.result:=$1.value>0
``` ## .sort()

<details><summary>Histórico</summary>
| Versão | Mudanças   |
| ------ | ---------- |
| v16 R6 | Adicionado |
</details>**.sort**( *methodName* : Text { ; *...extraParam* : any } ) : Collection| Parameter  | Type       |    | Description                                                       |
| ---------- | ---------- |:--:| ----------------------------------------------------------------- |
| methodName | Texto      | -> | Nome do método utilizado para especificar a ordem de clasificação |
| extraParam | any        | -> | Parâmetros para o método                                          |
| Result     | Collection | <- | Original collection sorted                                        |#### Description

The `.sort()` functionsorts the elements of the original collectionand also returns the sorted collection.
> This function modifies the original collection.

If `.sort()` is called with no parameters, only scalar values (number, text, date, booleans) are sorted. Elements are sorted by default in ascending order, according to their type.

If you want to sort the collection elements in some other order or sort any type of element, you must supply in *methodName* a comparison method that compares two values and returns **true** in *$1.result* if the first value is lower than the second value. Pode fornecer parâmetros adicionais a *methodName* se for necessário.

*   *methodName* will receive the following parameters:
    *   $1 (object), where:
        *   *$1.value* (any type): first element value to be compared
        *   *$1.value2* (any type): second element value to be compared
    *   $2...$N (any type): extra parameters

*methodName* sets the following parameter:
    *   *$1.result* (boolean): **true** if *$1.value < $1.value2*, **false** otherwise

Se a coleção conter elementos de tipos diferentes, são primeiro agrupados por tipo e ordenados depois. Tipos são retornados na ordem abaixo:

1.  null
2.  booleans
3.  strings
4.  numbers
5.  objetos
6.  collections
7.  dates

#### Example 1


```4d
 var $col; $col2 : Collection
 $col:=New collection("Tom";5;"Mary";3;"Henry";1;"Jane";4;"Artie";6;"Chip";2)
 $col2:=$col.sort() // $col2=["Artie","Chip","Henry","Jane","Mary","Tom",1,2,3,4,5,6]
  // $col=["Artie","Chip","Henry","Jane","Mary","Tom",1,2,3,4,5,6]

Example 2

 var $col; $col2 : Collection
 $col:=New collection(10;20)
 $col2:=$col.push(5;3;1;4;6;2).sort() //$col2=[1,2,3,4,5,6,10,20]

Exemplo 3

 var $col; $col2; $col3 : Collection
 $col:=New collection(33;4;66;1111;222)
 $col2:=$col.sort() //numerical sort: [4,33,66,222,1111]
 $col3:=$col.sort("numberOrder") //alphabetical sort: [1111,222,33,4,66]

  //numberOrder project method
 var $1 : Object
 $1.result:=String($1.value)<String($1.value2)
``` ## .sum()

<details><summary>Histórico</summary>
| Versão | Mudanças   |
| ------ | ---------- |
| v16 R6 | Adicionado |
</details>**.sum**( { *propertyPath* : Text } ) : Real| Parameter    | Type  |    | Description                                          |
| ------------ | ----- |:--:| ---------------------------------------------------- |
| propertyPath | Texto | -> | Rota de propriedade objeto a ser usado para cálculos |
| Result       | Real  | <- | Sum of collection values                             |#### Description

The `.sum()` functionreturns the sum for all values in the collection instance.

Apenas elementos numéricos são considerados para cálculos (outros tipos são ignorados).

Se a coleção contiver objetos, passe o parâmetro *propertyPath* para indicar a propriedade objeto para levar em consideração.

`.sum()` returns 0 if:

*   the collection is empty,
*   the collection does not contain numerical elements,
*   *propertyPath* is not found in the collection.

#### Example 1


```4d
 var $col : Collection
 var $vSum : Real
 $col:=New collection(10;20;"Monday";True;2)
 $vSum:=$col.sum() //32

Example 2

 var $col : Collection
 var $vSum : Real
 $col:=New collection
 $col.push(New object("name";"Smith";"salary";10000))
 $col.push(New object("name";"Wesson";"salary";50000))
 $col.push(New object("name";"Gross";"salary";10500,5))
 $vSum:=$col.sum("salary") //$vSum=70500,5
```## .unshift()

<details><summary>Histórico</summary>
| Versão | Mudanças   |
| ------ | ---------- |
| v16 R6 | Adicionado |
</details>**.unshift**( *value* : any { ;...*valueN* : any } ) : Collection| Parameter | Type                                   |    | Description                                           |
| --------- | -------------------------------------- |:--:| ----------------------------------------------------- |
| value     | Text, Number, Object, Collection, Date | -> | Value(s) to insert at the beginning of the collection |
| Result    | Real                                   | <- | Collection containing added element(s)                |#### Description

The `.unshift()` functioninserts the given *value*(s) at the beginning of the collectionand returns the modified collection.
> This function modifies the original collection.

If several values are passed, they are inserted all at once, which means that they appear in the resulting collection in the same order as in the argument list.


#### Exemplo


```4d
 var $c : Collection
 $c:=New collection(1;2)
 $c.unshift(4) // $c=[4,1,2]
 $c.unshift(5) //$c=[5,4,1,2]
 $c.unshift(6;7) // $c=[6,7,5,4,1,2]

Constante	Tipo	Valor	Comentário
ck ascending	Inteiro longo	0	Os elementos são ordenados de forma ascendente (por padrão)
ck descending	Longint	1	Os elementos são ordenados de forma descendente