Array Session

[Ecos 0]

Galera.

 

Bom Dia a Toldos.

 

Eu estou fazendo um e-commerce em ASP.

Eu não achei no Google como adicionar elementos em um Array em ASP, sem perder o que já está. Por exemplo:

 

<%
	Produtos = Request.QueryString("produto_codigo")
	Session("Carrinho") = Array(Session("Carrinho"), Produtos)
%>

Estou fazendo assim, está certo ?

 

E outra, como faço para excluir um DETERMINADO elemento do Array() ?

 

Vlw!

[Patrique 0]

http://www.mxstudio.com.br/marketingdigital/usabilidade/asp-arrays-dinamicos/

http://www.plugmasters.com.br/sys/materias/172/1/Criando-Array-automaticamente

[xanburzum 169]

"Ex:

ReDim preserve vetor ( UBound( vetor )+1) "Ubound vai retornar o número de elementos; some 1 para adicionar
vetor ( Ubound( vetor ) ) = "Novo Item 1"
ReDim preserve vetor ( UBound( vetor )+1)
vetor ( Ubound( vetor ) ) = "Novo Item 2"
ReDim preserve vetor ( UBound( vetor )+1)
vetor ( Ubound( vetor ) ) = "Novo Item 3"

 

Os Arrays ou matrizes são umas estruturas de dados muito utilizadas em Qualquer linguagem. Trata-se de variáveis, porém que estão preparadas para Salvar uma quantidade maior de elementos. É como uma variável que tem vários compartimentos para salvar a informação e a cada um desses compartimentos há que acessar como um índice.

 

Antes de utilizar um array devemos declara-lo de maneira obrigatória, para isso utilizamos a palavra chave DIM, deste modo.

 

dim Array(50)

Despois da palavra DIM devemos indicar o nome do array e a seguir, entre parênteses, coloca-se o número de posição máxima do array, neste caso 50.

 

Os arrays começam desde a posição 0, ou seja, o primeiro elemento de um array está na posição 0. Portanto, se o array foi definido com 50 campos, como no exemplo, terá 51 elementos, primeira posição será a 0 e a última posição seria a 50.

 

Para atribuir um valor a um array se realiza igual que uma variável, porém acessando com o índice da posição que queremos escrever.

 

Array(0) = 128

Para utilizar o conteúdo de um array devemos faze-lo indicando o índice ao que se deseja acessar. Por exemplo, se quiséssemos imprimir na página a primeira posição de nosso Array o faríamos desta maneira.

 

document.write(Array(0))

Agora vamos ver um exemplo sobre como utilizar os arrays, onde vamos realizar dois percorridos, um para escrever nele e o outro para ler a informação e escreve-la na página.

dim matriz (10)
for i=0 to 10
matriz(i)=100 * i
next
for i=0 to 10
document.writeln(“Posicao ” & i & “: ” & matriz(i) & “
“)
next

Este exemplo escreveria na página as posições do array, que contém variáveis numéricas que correspondem de multiplicar seu índice por 100.

Bom agora, que vimos como funciona os arrays iremos partir para Arrays dinâmicos.

 

Aplicação de Objetos com Arrays Dinâmicos

 

Dentro de qualquer aplicação que eventualmente é necessário o uso de matrizes de dados. Nós precisamos encontrar os dados para o objetos, a fim de simplificar a lógica que vai ser de execução, bem como para tornar o código mais flexível e escalável. Usando uma classe que engloba uma série de objetos, que se mantém e matriz de objetos, descobrimos que a classe superior nos permite adquirir uma forma simplificada de classificar, filtrar e controlar os itens de dados, bem como os valores desses itens de dados.

 

Essas classes simplificada permitirá que alcance rapidamente e aprender a usar um array dinâmico que mantém uma matriz dinâmica de objetos (ambas as matrizes dinâmicas objetos que estão sendo eles mesmos).

 

A camada mais profunda da nossa estrutura é uma classe simples de todos os atributos que você pode precisar de realizar.

 

‘*********** class ***************
‘Classe valor do item
Class item_value_class
Private c_item_value
‘ handle value (let/get)
public property let value(byval data)
c_item_value = data
end property
public property get value()
value = c_item_value
end property
end class
‘******************************************

Observe que esta classe tem um atributo com duas propriedades para permitir a escrita e leitura para o atributo. Isto é normal e não é nada especial. Passamos agora para a próxima camada, onde encontramos a nossa primeira matriz dinâmica.

 

‘********* classe média ***********************
Class item_class
Private c_item
Private c_values() ‘ Matriz de todos os valores para o item
Private c_size ‘ max determina os valores possíveis para o item

‘ handle item (let/get)
public property let item(byval data)
c_item = data
end property
public property get item()
item = c_item
end property

‘*************************************************
‘************* metodos ***************************
‘*************************************************

‘*********** Event Handlers *************
Private Sub Class_Initialize()
Redim c_values(0)
Set c_values(0) = New item_value_class
c_size=0
End Sub
‘ matar todos os objetos em Adata e livrar memória
Private Sub Class_Terminate()
Dim x
for x=0 to ubound(c_values)
Set c_values(0) = nothing
next
c_size=0
erase c_values
End Sub
‘****************************************
Public Function getValue(iPos)
getValue = c_values(iPos).value
End Function

Public Function putValue(iPos,data)
if iPos>c_size then
Redim preserve c_values(iPos)
for x = c_size+1 to ubound(c_values)
set c_values(x)= New item_value_class
next
c_size=iPos
end if
c_values(iPos).value=cstr(data)

End Function

Public Property get numbervalues()
numbervalues=c_size
end property

Public property get allvalues()
allvalues=c_values
end property

Public property let allvalues(ByRef temp)
Dim x
Dim sizetochange
sizetochange=ubound(temp)
if sizetochange < c_size then
for x=sizetochange+1 to ubound(c_values)
set c_values(x)=nothing
next
Redim preserve c_values(sizetochange)
else
Redim preserve c_values(sizetochange)
for x = c_size+1 to ubound(c_values)
set c_values(x)= New item_value_class
next
end if
c_size=sizetochange
for x=0 to sizetochange
c_values(x).value = temp(x).value
next
end property
end class
'******************************************

Vemos a instanciação de uma matriz de objetos de valor a nossa classe. Observe sempre que adicionar um valor com o método putValue nossa matriz é automaticamente aumentado e instanciado. Há uma propriedade especial chamada de "allvalues" que cria um ponto de referência para a matriz que esta classe possui. Para todos os valores do GET propriedade retorna a referência para a matriz, enquanto o imóvel locado nos permite definir um outro array de objetos da nossa classe de valor igual a outro. As propriedades allvalues tornam-se importantes em nossa camada superior chamada de Dynamic_Object_Array_Class ".

 

'******** classe superior *********************
Class Dynamic_Object_Array_Class
'************** Properties **************
Private aData()
Private c_size
'****************************************

'*********** Event Handlers *************
Private Sub Class_Initialize()
Redim aData(0)
Set aData(0) = New item_class
c_size=0
c_numberlinks=1
End Sub
' matar todos os objetos em Adata e livrar memória
Private Sub Class_Terminate()
Dim x
for x=0 to ubound(aData)
Set aData(0) = nothing
next
c_size=0
erase aData
End Sub
'****************************************
Public Property Get allitems()
allitems = aData
end property

Public Property Get getsize()
getsize = c_size
end property

Public Function push()
c_size = c_size+1
Redim preserve aData(c_size)
set aData(c_size)= New item_class
push=c_size
End Function

Public Function pop(ipos)
Dim tempcount
pop=aData(ipos).item
if ipos < c_size then
for tempcount=ipos to (c_size – 1)
aData(tempcount).item = aData(tempcount+1).item
aData(tempcount).allvalues = aData(tempcount+1).allvalues
next
end if
set aData(c_size)= nothing
c_size = c_size-1
Redim preserve aData(c_size)
End Function’
End Class
'********** classe superior final ***************

A classe superior implementa um push-pop e um método para aumentar automaticamente ou diminuir o array de objetos da nossa classe de item que a classe superior detém. Observe que o método de classe anteriores allvalues é implementada no método pop na nossa class = mais alto. Agora que temos a nossa matriz dinâmica, devemos colocá-lo para uso. A maneira mais fácil de ver como ele funciona é a de armazenar alguns dados na matriz e em seguida, exibi-la novamente.

 

'******** Exemplo de código usando Array Dinâmico *****

 

<%
for y=0 to my_array.getsize
Response.Write ""
for x=0 to my_array.allitems()(y).numbervalues
if my_array.allitems()(y).getValue(x)”" then
Response.Write “”
end if
next
next
%>
Item: 	” & _
“ 	” & _
my_array.allitems()(y).item & _
“ 	
	” & _
“ 	Value: 	” & _
my_array.allitems()(y).getValue(x) & “

‘********************************************

Depois de executar o nosso código de exemplo, devemos ver o seguinte em nosso navegador da Web:

 

‘******* Exemplo de Output *********************

Item: Olá
Item: TRUE FALSE
Value: yes
Value: no
Item: Seu Nome
Item: Outro Item
Item: Lugar em Concurso
Value: Terceiro
Value: segundo
Value: Primeiro
Item: Escolha o Hotel
Value: Nacional Inn
Value: Ibis

‘********* end example output ****************

Arrays dinâmicos de objetos que contêm matrizes dinâmicas dos objetos nos permitem criar a estrutura que precisamos de uma forma simplificada e reutilizáveis. Nossas matrizes também serão auxiliadas na classificação, filtragem e manipulação de dados. Apesar de eu não ter incluído o código de exemplo para a classificação e filtragem, uma vez que você entender como funcionam as classes, gerando a classificação e os métodos de filtragem é bastante fácil.

Podemos ainda, Redimensionar arrays

Este tipo de arrays redimensionais se chama array dinâmico. Para criar este tipo de arrays podemos utilizar a sentença dim (como criávamos os anteriores) ou a sentença redim, com a particularidade que não lhe colocamos nenhum valor entre parênteses onde antes indicávamos o número de campos do array.

 

dim meu_array()
redim meu_outro_array()

Quando usamos arrays dinâmicos podemos utilizar a sentença redim para indicar o número de dimensões e a quantidade de campos de cada dimensão.

 

Com esta sentença estamos indicando que meu_array deve ter o tamanho 10. Campos desde 0 até a 10.

 

redim meu_array(10)

Se indicamos a chave “preserve” estamos garantindo que o conteúdo dos campos que havia previamente no array se mantém.

 

redim preserve meu_array(20)

Por último, se em qualquer momento reduzimos o número de campos perderemos o que possa ter sido salvo nos campos que se eliminaram.

 

No seguinte exemplo criamos um array dinâmico e o redimensionamos inicialmente a tamanho 3. Preenchemos e mostramos seus distintos valores. Posteriormente o redimensionamos outra vez para que chegue até a posição 7, salvando os valores antigos. Para acabar preenchendo os campos que criamos novos e mostramos todos os valores do array.

 

dim frutas()
redim frutas(3)

frutas(0) = “Pêra”
frutas(1) = “Uva”
frutas(2) = “Maçã”
frutas(3) = “Melão”

for each fruta in frutas
document.write fruta & “
”
next

redim preserve frutas(7)

frutas(4) = “Melancia”
frutas(5) = “Laranja”
frutas(6) = “Banana”
frutas(7) = “Tangerina”

for each fruta in frutas
document.write fruta & “
”
next

Para saber o número de campos de um array

 

Um dos dados típicos que necessitamos extrair de um array é seu número de posições, útil, por exemplo, para fazer um percorrido a um array, desde a primeira até o último campo. Para isso, utilizamos a função uBound() de VBScript. A função UBound permite descobrir o que o membro da matriz superior é definida. Isto torna mais fácil o loop para percorrer um array do início ao fim.

 

Digamos que você usa a função split para analisar uma string em um array. Então você:

 

Dim ListaArray

 

SentStr = ” Oitenta e sete anos atrás nossos pais trouxeram ”

ListaArray = split(SentStr, ” “)

 

Agora você tem uma matriz listarray que pretende percorrer, mas você não sabe até onde ir. Como saber quando você tiver chegado ao final do array ?

 

A resposta é a função UBound. ubound dá-lhe o membro superior matriz de uma matriz. Neste caso, a matriz tem 10 palavras na mesma. O arrays começam sempre a numeração em zero, significa que essa matriz pontos de 0 a 9 são tomadas. Se você fizer

ubound(ListArray)

 

O resultado é 9.

 

Você pode então fazer um loop através dos membros, que operam em cada um .

 

for loopctr = 0 to ubound(ListaArray)
response.write ListaArray(loopctr)
next

Outro Exemplo:

 

dim paises (4)
response.write ubound (paises)

Escreveria na página o número do campo mais alto do array paises, neste caso 4.

Ademais, se por acaso algum dia necessitamos, também temos a nossa disposição a função lBound(), que devolve o número da posição com índice menor do array.

response.write lbound (paises)

 

A última linha sobre nosso array de paises definido anteriormente escreveria um 0 na página web, visto que o array começa na posição zero.

 

Arrays multidimensionais

 

Podem-se construir matrizes multidimensionais, ou seja, que nos permitam criar matrizes de várias coordenadas. Para trabalhar com eles utiliza-se uma vírgula que separa os dois índices. Por exemplo, podemos definir uma matriz de 10×10 desta maneira.

 

dim Array2Dimensoes (9,9)

Como o array é de 10 campos, utilizamos um 9 e suas posições serão as 10 que vão desde o 0 ao 9. Para escrever e ler do Array podemos utilizar a vírgula de maneira similar a como se declara. Por exemplo, para colocar dados na posição 0,4 faríamos o seguinte:

 

Array2Dimensoes (0,4) = “texto posicao 0,4″

Abaixo, temo um exemplo de como armazenar o conteúdo do vetor em uma session, muito usada pelo pessoal de e-commerce para carrinhos de compras.

<%
"A função abaixo é generica e pode ser utilizada como um arquivo include
Function VetorMonta(Acao,Valor)
"Usamos o case para manipular a ação da função
Select Case Trim(Acao)
"Inclui nova posicao ao vetor
Case "Incluir"
"Guarda na variavel Vetor o conteudo da Session
Vetor = Session("GuardaVetor")
"Verifica se a Variavel Vetor é um Array, caso nao for entao definimos ela um Array
If Not IsArray(Vetor) Then Vetor = Array() End if
"Verifica se o Valor que esta sendo inserido já esta no Vetor se estiver entao nao inseri para nao haver duplicidades do vetor
If InStr(Join(Vetor), Valor) = 0 Then
"Este comando ira preservar o vetor e adciona + 1 valor
ReDim preserve Vetor(UBound(Vetor)+1)
"Este é o valor que estamos adicionando no vetor
Vetor(Ubound(Vetor )) = Valor
"Coloca o conteudo da variavel vetor dentro da Session
Session("GuardaVetor") = Vetor
End if
"Apaga uma determinada posicao do vetor
Case "Excluir"
"Inicia a varivel vetor como vazia
Vetor = Array()
"Criamos uma nova variavel Auxiliar e guardamos o valor da Session
AuxVetor = Session("GuardaVetor")
"Definine a Session como um Array vazio
Session("GuardaVetor") = Array()
"Faz um laço em todas as posições do vetor
For i = 0 To Ubound(AuxVetor)
"Verifica se o valor passado para excluir do vetor é diferente do valor que esta dentro da variavel Auxiliar
If AuxVetor(i) (Valor) Then
“Este comando ira preservar o vetor e adciona + 1 valor
ReDim preserve Vetor (UBound(Vetor)+1)
“Este é o valor que estamos adicionando no vetor
Vetor (Ubound(Vetor)) = AuxVetor(i)
“Coloca o conteudo da variavel vetor dentro da Session
Session(“GuardaVetor”) = Vetor
End If
Next
“Fim do Case
End Select
End Function
Function Incluir_Vetor
“Executa a função que ira criar uma posição do vetor, basta passar a acao e o valor
Call VetorMonta(“Incluir”,Replace(Request(“Valor_Vetor”),”"”,”"))
End Function
Function Excluir_Vetor(Valor_Vetor)
“Executa a função que ira deletar uma posição do vetor, basra passar a acao e o valor
Call VetorMonta(“Excluir”,Valor_Vetor)
End Function
Function VisualizaValoresVetor
“Veriofica se a Session é um array, caso nao for então atribuimos a Session como um Array
IF Not IsArray(session(“GuardaVetor”)) Then session(“GuardaVetor”) = Array() End if
“Faremos um laço entre todos os vetores criados
For x = 0 To ubound(session(“GuardaVetor”)) “ira fazer um laço mostrando todos os vetores criados
“Mostra os valores armazenados na Session e adiciona um link para apagar a posição do vetor caso queira
Response.Write session(“GuardaVetor”)(x) & “(Apagar)” & “
”
Next
“Verifica se a Session tem alguma posição, se tiver mostra a opção de apagar todos os vetores
If ubound(session(“GuardaVetor”)) >= 0 Then
Response.Write “
” &”Apagar Tudo” & “
” “Imprime o Vetor na tela
End if
End Function
Function LimpaVetor
“Limpa todas as posiçoes do vetor, apagando a Session
session(“GuardaVetor”) = Empty
End Function
“USAMOS CASES PARA MANUPULARAS CHAMADAS DAS FUNÇÕES
useraction=request(“action”)
select case useraction
Case “Incluir_Vetor”
“Chama a function que ira incluir um valor para o vetor
Call Incluir_Vetor
Case “Excluir_Vetor”
“Chama a function que ira excluir um valor para o vetor
Call Excluir_Vetor(Request(“Valor_Vetor”))
Case “LimpaVetor”
“Chama a function que apagar todas as posições do vetor
Call LimpaVetor
End Select
%>

[Patrique 0]

Velho... não entendo pra que você posta um conteúdo que eu havia postado o link acima do seu post... e além disso não referencia a fonte... pra mim isso é flood...