# Peek Funzione script

Peek() restituisce il valore di un campo in una tabella per una riga che è già stata caricata. È possibile specificare il numero di riga così come la tabella. Se non viene specificato alcun numero di riga, verrà utilizzato l'ultimo record precedentemente caricato.

La funzione `Peek()` viene principalmente utilizzata per trovare i limiti pertinenti in una tabella precedentemente caricata, ovvero, il primo valore o l'ultimo valore di un campo specifico. Nella maggior parte dei casi, questo valore viene archiviato in una variabile per l'utilizzo futuro, ad esempio, come una condizione in un loop do-while.

Sintassi:

Peek(

field\_name

[, row\_no[, table\_name ] ])

Tipo di dati restituiti: duale

Argomenti:

Argomenti

| Argomento | Descrizione |
| --- | --- |
| field\_name | Nome del campo per cui è richiesto il valore restituito.Il valore di input deve essere specificato come stringa (ad esempio, un valore letterale tra virgolette). |
| row\_no | La riga nella tabella che specifica il campo richiesto. Può essere un'espressione, tuttavia deve restituire un numero intero. 0 indica il primo record, 1 indica il secondo e così via. I numeri negativi indicano l'ordine dalla fine della tabella. -1 indica l'ultimo record letto.<br><br>Se non viene dichiarato alcun valore row\_no verrà utilizzato il valore -1. |
| table\_name | Un'etichetta di tabella senza due punti finali. Se non è dichiarato table\_name, viene utilizzata la tabella attuale. Se utilizzato al di fuori dell'istruzione LOAD o se fa riferimento a un'altra tabella, è necessario includere table\_name. |

Limiti:

La funzione può solo restituire valori da record già caricati. Questo significa che nel primo record di una tabella, una chiamata che usa -1 come `row_no` restituirà NULL.

[](https://help.qlik.com/en-US/cloud-services/Subsystems/Hub/Content/Sense_Hub/Scripting/InterRecordFunctions/Peek.htm)

#### Esempi e risultati:

## Esempio 1

Aggiungere lo script di esempio alla propria applicazione ed eseguirlo. Per visualizzare il risultato, aggiungere i campi elencati nella colonna dei risultati a un foglio nella propria applicazione.

```
EmployeeDates:
Load * Inline [
EmployeeCode|StartDate|EndDate
101|02/11/2010|23/06/2012
102|01/11/2011|30/11/2013
103|02/01/2012|
104|02/01/2012|31/03/2012
105|01/04/2012|31/01/2013
106|02/11/2013|
] (delimiter is '|');
     
First_last_Employee:
Load 
EmployeeCode, 
Peek('EmployeeCode',0,'EmployeeDates') As FirstCode, 
Peek('EmployeeCode',-1,'EmployeeDates') As LastCode
Resident EmployeeDates;
```

Tabella risultante

| Employee code | StartDate | EndDate | FirstCode | LastCode |
| --- | --- | --- | --- | --- |
| 101 | 02/11/2010 | 23/06/2012 | 101 | 106 |
| 102 | 01/11/2011 | 30/11/2013 | 101 | 106 |
| 103 | 02/01/2012 |  | 101 | 106 |
| 104 | 02/01/2012 | 31/03/2012 | 101 | 106 |
| 105 | 01/04/2012 | 31/01/2013 | 101 | 106 |
| 106 | 02/11/2013 |  | 101 | 106 |

FirstCode = 101 poiché`  Peek('EmployeeCode',0, 'EmployeeDates') ` restituisce il primo valore di EmployeeCode nella tabella EmployeeDates.

LastCode = 106 perché`  Peek('EmployeeCode',-1, 'EmployeeDates') ` restituisce l'ultimo valore di EmployeeCode nella tabella EmployeeDates.

La sostituzione del valore dell'argomento row\_no restituisce i valori delle altre righe nella tabella, nel modo seguente:

`  Peek('EmployeeCode',2, 'EmployeeDates') ` restituisce il terzo valore, 103, nella tabella come FirstCode.

Tuttavia, tenere presente che se non si specifica la tabella come il terzo argomento table\_name in questi esempi, la funzione farà riferimento alla tabella attuale (in questo caso, interna).

## Esempio 2

Se si desidera accedere ai dati più in profondità in una tabella, è possibile farlo in due passaggi: prima, caricare l'intera tabella in una tabella temporanea, quindi riordinarla quando si usa Peek().

Aggiungere lo script di esempio alla propria applicazione ed eseguirlo. Per visualizzare il risultato, aggiungere i campi elencati nella colonna dei risultati a un foglio nella propria applicazione.

```
T1:
LOAD * inline [
ID|Value
1|3
1|4
1|6
3|7
3|8
2|1
2|11
5|2
5|78
5|13
] (delimiter is '|');

T2:

LOAD *,
IF(ID=Peek('ID'), Peek('List')&','&Value,Value) AS List
RESIDENT T1
ORDER BY ID ASC;
DROP TABLE T1;
```

Create a table in a sheet in your application with ID, List, and Value as the dimensions.

Tabella risultante

| ID | Elenco | Valore |
| --- | --- | --- |
| 1 | 3,4 | 4 |
| 1 | 3,4,6 | 6 |
| 1 | 3 | 3 |
| 2 | 1,11 | 11 |
| 2 | 1 | 1 |
| 3 | 7,8 | 8 |
| 3 | 7 | 7 |
| 5 | 2,78 | 78 |
| 5 | 2,78,13 | 13 |
| 5 | 2 | 2 |

L'istruzione IF() viene creata a partire dalla tabella temporanea T1.   
`Peek('ID')` fa riferimento al campo ID nella riga precedente nella tabella corrente T2.  
`Peek('List')` fa riferimento al campo List nella riga precedente nella tabella T2, attualmente in fase di creazione mentre l'espressione viene valutata.

L'istruzione viene valutata nel seguente modo:  
Se il valore attuale di ID è identico al valore precedente di ID, scrivere il valore di Peek('List') concatenandolo con il valore corrente di Value. In alternativa, scrivere solo il valore attuale di Value.

Se Peek('List') contiene già un risultato concatenato, il nuovo risultato di Peek('List') verrà concatenato a tale risultato.

Nota informaticaPrendere nota della clausola Order by. Questa clausola specifica il metodo di ordinamento della tabella (in base all'ID in ordine crescente). Senza questa clausola, la funzione Peek() utilizzerebbe qualsiasi ordinamento arbitrario presente nella tabella interna, portando a risultati potenzialmente imprevedibili.

## Esempio 3

Aggiungere lo script di esempio alla propria applicazione ed eseguirlo. Per visualizzare il risultato, aggiungere i campi elencati nella colonna dei risultati a un foglio nella propria applicazione.

```
Amounts:
Load 
Date#(Month,'YYYY-MM') as Month,
Amount,
Peek(Amount) as AmountMonthBefore 
Inline
[Month,Amount
2022-01,2
2022-02,3
2022-03,7
2022-04,9
2022-05,4
2022-06,1];
        
```

Tabella risultante

| Amount | AmountMonthBefore | Month |
| --- | --- | --- |
| 1 | 4 | 2022-06 |
| 2 | - | 2022-01 |
| 3 | 2 | 2022-02 |
| 4 | 9 | 2022-05 |
| 7 | 3 | 2022-03 |
| 9 | 7 | 2022-04 |

Il campo AmountMonthBefore conterrà l'importo dal mese precedente.

Qui i parametri row\_no e table\_name vengono omessi, pertanto vengono utilizzati i valori predefiniti. In questo esempio, le seguenti tre chiamate di funzione sono equivalenti:

* Peek(Amount)
* Peek(Amount,-1)
* Peek(Amount,-1,'Amounts')

L'utilizzo di -1 come row\_no indica che verrà utilizzato il valore dalla riga precedente. Sostituendo tale valore, sarà possibile recuperare i valori delle altre righe nella tabella:

Peek(Amount,2) restituisce il terzo valore nella tabella: 7.

## Esempio 4

I dati devono essere ordinati correttamente per ottenere i risultati corretti ma, sfortunatamente, questo non è sempre il caso. Inoltre, la funzione Peek() non può essere utilizzata per fare riferimento a dati che non sono ancora stati caricati. Utilizzando tabelle temporanee ed eseguendo più passaggi attraverso i dati, questi problemi possono essere evitati.

Aggiungere lo script di esempio alla propria applicazione ed eseguirlo. Per visualizzare il risultato, aggiungere i campi elencati nella colonna dei risultati a un foglio nella propria applicazione.

```
tmp1Amounts:
Load * Inline
[Month,Product,Amount
2022-01,B,3
2022-01,A,8
2022-02,B,4
2022-02,A,6
2022-03,B,1
2022-03,A,6
2022-04,A,5
2022-04,B,5
2022-05,B,6
2022-05,A,7
2022-06,A,4
2022-06,B,8];

tmp2Amounts:
Load *,
If(Product=Peek(Product),Peek(Amount)) as AmountMonthBefore
Resident tmp1Amounts
Order By Product, Month Asc; 
Drop Table tmp1Amounts;

Amounts:
Load *,
If(Product=Peek(Product),Peek(Amount)) as AmountMonthAfter
Resident tmp2Amounts
Order By Product, Month Desc; 
Drop Table tmp2Amounts;
```

Spiegazione

La tabella iniziale è ordinata in base al mese, il che significa che la funzione peek() restituirebbe in molti casi l'importo del prodotto sbagliato. Quindi, questa tabella deve essere riordinata. Ciò avviene eseguendo un secondo passaggio attraverso i dati creando una nuova tabella tmp2Amounts. Prendere nota della clausola Order by. Ordina i record prima per prodotto, poi per mese in ordine crescente.

La funzione If() è necessaria poiché AmountMonthBefore dovrebbe essere calcolato solo se la riga precedente contiene i dati per lo stesso prodotto ma per il mese precedente. Confrontando il prodotto sulla riga corrente con il prodotto sulla riga precedente, questa condizione può essere convalidata.

Quando viene creata la seconda tabella, la prima tabella tmp1Amounts viene eliminata utilizzando un'istruzione Drop Table.

Infine, viene fatto un terzo passaggio attraverso i dati, ma ora con i mesi ordinati in ordine inverso. In questo modo, può essere calcolato anche AmountMonthAfter.

Nota informaticaLe clausole Ordina per specificano come è ordinata la tabella; senza di loro, la funzione Peek() userà qualsiasi ordine arbitrario della tabella interna, il che può portare a risultati imprevedibili.

Risultato

Tabella risultante

| Month | Product | Amount | AmountMonthBefore | AmountMonthAfter |
| --- | --- | --- | --- | --- |
| 2022-01 | A | 8 | - | 6 |
| 2022-02 | B | 3 | - | 4 |
| 2022-03 | A | 6 | 8 | 6 |
| 2022-04 | B | 4 | 3 | 1 |
| 2022-05 | A | 6 | 6 | 5 |
| 2022-06 | B | 1 | 4 | 5 |
| 2022-01 | A | 5 | 6 | 7 |
| 2022-02 | B | 5 | 1 | 6 |
| 2022-03 | A | 7 | 5 | 4 |
| 2022-04 | B | 6 | 5 | 8 |
| 2022-05 | A | 4 | 7 | - |
| 2022-06 | B | 8 | 6 | - |

## Esempio 5

Aggiungere lo script di esempio alla propria applicazione ed eseguirlo. Per visualizzare il risultato, aggiungere i campi elencati nella colonna dei risultati a un foglio nella propria applicazione.

```
T1:
Load * inline [
Quarter, Value
2003q1, 10000
2003q1, 25000
2003q1, 30000
2003q2, 1250
2003q2, 55000
2003q2, 76200
2003q3, 9240
2003q3, 33150
2003q3, 89450
2003q4, 1000
2003q4, 3000
2003q4, 5000
2004q1, 1000
2004q1, 1250
2004q1, 3000
2004q2, 5000
2004q2, 9240
2004q2, 10000
2004q3, 25000
2004q3, 30000
2004q3, 33150
2004q4, 55000
2004q4, 76200
2004q4, 89450 ];

T2:
Load *, rangesum(SumVal,peek('AccSumVal')) as AccSumVal;
Load Quarter, sum(Value) as SumVal resident T1 group by Quarter;
```

Risultato

Tabella risultante

| Quarter | SumVal | AccSumVal |
| --- | --- | --- |
| 2003q1 | 65000 | 65000 |
| 2003q2 | 132450 | 197450 |
| 2003q3 | 131840 | 329290 |
| 2003q4 | 9000 | 338290 |
| 2004q1 | 5250 | 343540 |
| 2004q2 | 24240 | 367780 |
| 2004q3 | 88150 | 455930 |
| 2004q4 | 220650 | 676580 |

Spiegazione

L'istruzione LOAD Load \*, rangesum(SumVal,peek('AccSumVal')) as AccSumVal include una chiamata ricorsiva dove i valori precedenti vengono aggiunti al valore corrente. Questa operazione è utilizzata per calcolare un accumulo di valori nello script.

## Ulteriori informazioni

* [Etichette di tabella](https://help.qlik.com/it-IT/cloud-services/Subsystems/Hub/Content/Sense_Hub/Scripting/table-labels.htm)
* [Previous Funzione script](https://help.qlik.com/it-IT/cloud-services/Subsystems/Hub/Content/Sense_Hub/Scripting/InterRecordFunctions/Previous.htm)