| Oratore |
Trascrizione |
| wendymurphrey |
Buongiorno e grazie per aver partecipato alla nostra presentazione di oggi. Siamo entusiasti di parlare con voi di scenari comuni che gli autori di script, con diversi livelli di esperienza, si trovano ad affrontare. |
| |
Il nostro intento è spiegare cosa sta succedendo in modo che tu abbia gli strumenti e le conoscenze per evitare questi errori. Quindi, iniziamo. |
| |
Forse perché non è aperto di default, è facile dimenticarsi di controllare il log per i messaggi. Ma il log contiene informazioni utili sulle recenti esecuzioni degli script. Diamo quindi un'occhiata più da vicino a questo esempio in JMP. |
| |
Qui possiamo vedere che lo script apre semplicemente una tabella dati e tenta di selezionare una riga. Quando eseguiamo questo script, |
| |
Viene visualizzato un messaggio di errore interattivo per gli errori fatali, ovvero quelle situazioni in cui lo script si interrompe a causa dell'errore. La finestra pop-up è una novità di JMP 15 e può essere disattivata nelle preferenze. |
| |
Quando eliminiamo quel messaggio, possiamo controllare il registro e vediamo lo stesso messaggio dalla finestra, ma vediamo anche il numero di riga |
| |
e il nome del file script per guidarci verso l'area interessata dal problema. Ora, non affidarti esclusivamente a queste finestre pop-up perché nel registro appariranno anche altri messaggi importanti, |
| |
e non necessariamente causano una finestra pop-up. Quindi diamo un'occhiata a un altro esempio. |
| |
In questo script, l'autore tenta di aprire una tabella, creare un'analisi e stampare un messaggio nel registro. |
| |
E quando eseguiamo questo script, notiamo subito che la nostra analisi non è stata generata. |
| |
Quindi, controlliamo di nuovo il registro |
| |
e vediamo che c'era una colonna che non è stata trovata nella tabella dati, ma lo script ha continuato e ha stampato il nostro messaggio nel registro. |
| |
Quindi, la cosa importante da tenere a mente è controllare sempre il registro, soprattutto quando ciò che accade non soddisfa le aspettative. Potrebbe trattarsi semplicemente di un errore di ortografia nel nome di una colonna. |
| |
Il concetto di tabella dati corrente è spesso descritto come tabella attiva. Ma cosa rende la tabella attiva o corrente e perché è importante per il tuo script? |
| |
Quando una tabella viene aperta, creata o utilizzata in altro modo, diventa la tabella dati corrente. Ma ci sono altri modi in cui una tabella può diventare corrente in fase di esecuzione che l'autore dello script potrebbe non aver previsto. |
| |
Le attività che JMP elabora in background. Ad esempio, JMP potrebbe dover valutare una formula o aggiornare una finestra. |
| |
Sono questi processi in background che possono causare l'attivazione di una tabella diversa da quella che si desiderava attivare in fase di esecuzione. Questo può causare il fallimento dello script o, peggio ancora, far sì che non ci si accorga nemmeno che JMP ha utilizzato la tabella sbagliata. |
| |
Quindi qui ne abbiamo forniti alcuni |
| |
Le migliori pratiche per creare i tuoi script utilizzando riferimenti specifici per le tabelle dati. In questo modo puoi garantire che venga utilizzata la tabella corretta, indipendentemente da quale tabella sia attiva in fase di esecuzione. |
| |
In questo esempio, mostriamo come inviare una chiamata bivariata a una tabella dati specifica per garantire che i dati in quella tabella vengano utilizzati per l'analisi. |
| |
È possibile utilizzare la nuova colonna anche come messaggio per una tabella dati specifica, assicurandosi che la nuova colonna venga creata nella tabella desiderata e non in quella corrente. |
| |
È anche possibile utilizzare riferimenti opzionali alle tabelle dati. Qui, stiamo solo mostrando come utilizzarli per fare riferimento alle colonne e parleremo più dettagliatamente di questo argomento tra poco. |
| |
È anche possibile utilizzare riferimenti facoltativi a tabelle di dati nelle funzioni; per ogni riga e riepilogo sono disponibili due casi in cui ciò è possibile. |
| |
Ti suggeriamo inoltre di evitare di utilizzare una tabella dati... assegnando un riferimento a una tabella dati tramite la funzione "current data table" negli script di produzione. In questo esempio, stiamo unendo due tabelle dati e vorremmo assegnare un riferimento a quella tabella. |
| |
che viene creato dal join. Ora, join restituisce un riferimento alla tabella appena creata. Quindi, invece di assegnare alla tabella dati corrente, vogliamo assegnare il riferimento quando viene creato il join. |
| |
Quindi qui, eseguiamo semplicemente la nostra assegnazione quando chiamiamo il join e quando eseguiamo questo |
| |
possiamo vedere che in effetti la nostra nuova variabile DT fa riferimento alla tabella desiderata e non è influenzata dalla tabella corrente. |
| |
Essere in grado di identificare una colonna utilizzando una variabile JSL è un'attività comune e il metodo da utilizzare dipende dall'uso previsto. |
| |
La funzione colonna restituisce un riferimento alla colonna come unità completa. Accetta diversi argomenti, ad esempio il nome della colonna è una stringa o una variabile stringa, |
| |
Un indice o una variabile numerica che rappresenta un indice. Può essere indicizzato per fare riferimento al valore della colonna su una riga specifica. |
| |
La funzione colonna può essere utilizzata ad esempio nelle chiamate alla piattaforma, nell'invio di messaggi a una colonna o nell'assegnazione di un riferimento a una variabile a una colonna. |
| |
La funzione as column restituisce un riferimento al valore sulla riga corrente |
| |
della colonna specificata. Accetta tutti gli stessi argomenti della funzione colonna, ma è importante capire che in JMP la riga corrente è sempre zero, a meno che non venga gestita diversamente. |
| |
Quindi, alcuni ottimi posti in cui utilizzare la funzione "come colonna" sono nelle formule, per ogni riga, e "seleziona dove", perché controllano la riga mentre valutano ogni riga in base alla loro progettazione. Vediamo un esempio di cosa intendiamo. |
| |
Qui stiamo aprendo una tabella dati di esempio. Abbiamo assegnato una variabile JSL al nome di una colonna e stiamo provando a utilizzare la funzione column nel nostro select where. |
| |
Ora, quando eseguiamo questo script, scopriamo che non è stata selezionata alcuna riga. Perché? Perché select where valuta ogni riga, |
| |
Utilizzando la funzione colonna senza alcun indice non verrà selezionata alcuna riga. Ricordiamo inoltre che la funzione colonna restituisce un riferimento alla colonna come unità intera, quindi un'intera colonna di dati non sarà mai uguale a 14. |
| |
Quindi le soluzioni consistono nell'utilizzare la funzione colonna con un indice di riga (e questo indice di riga indica semplicemente la riga corrente, qualunque essa sia mentre select where sta valutando), oppure è possibile utilizzare la funzione colonna as per selezionare le righe. |
| |
L'uso di una variabile JSL nelle formule può essere problematico per diversi motivi. La durata di una variabile JSL è limitata alla sessione JMP corrente e, man mano che il valore della variabile cambia, può cambiare anche il risultato della formula. |
| |
E se non guardi la formula nell'editor di formule, potresti non renderti conto di avere un problema. |
| |
Diamo un'occhiata al nostro esempio. Qui, apro semplicemente una tabella dati e creo un elenco di colonne che vorrei sommare. |
| |
Sto creando la mia nuova colonna formula e sto usando la mia variabile JSL nella funzione somma. Quindi eseguiamolo. Possiamo vedere che la nostra nuova colonna è stata creata e popolata con i dati. Ma diamo un'occhiata all'editor di formule. Non abbiamo mai detto che la nostra variabile JSL è stata usata nella funzione somma. |
| |
E quando lo ignoriamo e apportiamo una modifica a una delle colonne dipendenti, notiamo anche che la formula della nostra colonna non viene aggiornata automaticamente. |
| |
Salviamo e chiudiamo JMP, salviamo questa tabella e chiudiamo JMP. |
| |
E ricominceremo. |
| |
Ora ricorda che la durata di quella variabile JSL era limitata alla precedente sessione JMP. Apriamo quindi la tabella e diamo un'occhiata a cosa succede. |
| |
Abbiamo notato che le formule della colonna variabile...non venivano ancora valutate. Quando diamo un'occhiata, vediamo ancora la nostra variabile JSL, ma ora abbiamo una linea rossa sotto. E passandoci sopra con il mouse, vediamo l'errore "nome non risolto". |
| |
Se proviamo a rivalutare la formula, riceviamo il messaggio di errore e ignorare gli errori causerà la modifica di tutti i dati come mancanti. Come possiamo risolvere questo problema? |
| |
Quando si utilizza una variabile in una formula, è necessario fare qualcosa per indicare a JMP di sostituire la variabile con il suo valore prima di valutare la formula. È possibile utilizzare "sostituto" per questo scopo, ma oggi illustreremo le funzioni di espressione. Quindi chiudiamo questa tabella. |
| |
Apriremo una nuova copia della tabella e ripristineremo l'elenco delle colonne. |
| |
E ora vediamo come possiamo aggirare questo problema. |
| |
Quindi la funzione di espressione eval indica a JMP di valutare e sostituire tutte le variabili presenti nel suo argomento che sono racchiuse in una funzione EXPR. |
| |
E poi restituirà l'espressione non valutata. Quindi, in questo codice, JMP sostituirà l'espressione "punteggi SAT" con il nostro elenco di colonne. |
| |
Quindi eseguiamo solo questa sezione e vediamo cosa succede. E vediamo che la funzione somma ora ha l'elenco delle colonne che vogliamo sommare al posto della variabile. |
| |
Ma in realtà non ha creato la colonna per noi. Ha semplicemente restituito questa espressione. Quindi, per valutarla, aggiungiamo una funzione eval attorno alla nostra funzione eval expression. |
| |
Questo farà sì che JMP valuti l'intera espressione della nuova colonna dopo la sostituzione. Quindi, in sostanza, l'email dice: esegui... esegui ciò che viene restituito dall'espressione eval, ovvero questo. |
| |
Quindi eseguiamolo e possiamo vedere che la nostra colonna è stata creata e abbiamo i dati come previsto. |
| |
E la nostra formula non ha più la nostra variabile, ha il nostro elenco di colonne. |
| |
E quando apportiamo una modifica ai dati in una colonna dipendente, la nostra formula ora si aggiorna automaticamente. |
| |
Adesso passo la parola a Justin, che ci consiglierà altri errori da evitare. |
| Justin Chilton |
Bene, un altro errore che vediamo commettere è quando si impostano le proprietà delle colonne, e la sintassi può essere un po' complicata. Quindi, prima di entrare nei dettagli, |
| |
Parliamo di cosa è una colonna in termini di proprietà di colonna. Quindi, in sostanza, una colonna è solo un |
| |
repository per queste informazioni sulla proprietà. Non esegue alcun controllo sintattico per assicurarsi che |
| |
Ciò che gli dai è corretto e questo gli permette di memorizzare qualsiasi cosa desideri. Questo perché il fruitore della proprietà si aspetta che qualcosa sia in un formato specifico, che si tratti di una piattaforma JMP, di una proprietà di colonna o persino di un'applicazione JSL. |
| |
Diamo un'occhiata a un rapido esempio. |
| |
E qui, apriremo una tabella che abbiamo chiamato proprietà di colonna, solo per i test. Abbiamo una colonna chiamata NPN1 e una colonna chiamata test. Questa colonna ha limiti di specifica e una proprietà di accesso, ma vogliamo |
| |
Aggiungiamo le proprietà del limite di specifica da testare. Quindi abbiamo qui quello che pensiamo |
| |
è la sintassi corretta per impostare le proprietà della colonna dei limiti delle specifiche. Lo eseguiamo e non ci dà un errore, ma quando |
| |
guarda la colonna, ci sono dei limiti di specifica per quella colonna. |
| |
E puoi, ma puoi dire che non è corretto. Quando abbiamo chiesto un'analisi della capacità di processo con i nostri limiti di specifica, |
| |
Quando eseguiamo il comando, ne otteniamo uno per NPN1, ma non uno per la colonna di test. Questo perché i dati memorizzati nella proprietà dei limiti di specifica per la colonna di test non sono corretti. |
| |
Quindi un modo per farlo se sai già come utilizzare i limiti delle specifiche delle proprietà impostate, |
| |
Puoi semplicemente inviare il messaggio di proprietà alla colonna NPN1, che è la colonna che sappiamo essere corretta. Quindi, se eseguiamo solo quella riga, otteniamo la sintassi corretta. |
| |
E questo ci mostra che in realtà dovrebbe essere in formato elenco invece che con argomenti separati. Un altro modo, se non si ha familiarità con la proprietà get, è andare alla colonna che si sa essere corretta e copiare le proprietà della colonna. |
| |
Quindi puoi incollarlo nel tuo script e vedrai che hai aggiunto proprietà di colonna e un paio di proprietà di set. Quindi aggiungere proprietà di colonna è solo un modo per raggruppare più proprietà di set. Possiamo rimuovere questa opzione e rimuovere l'accesso extra. |
| |
proprietà. Quindi, una volta rimossa, possiamo usare questa proprietà set per inviarla alla nostra colonna di test con l'operatore di invio. Quindi, quando eseguiamo questo, |
| |
noi...è...ha sovrascritto i nostri limiti di specifica, ma possiamo confermarlo eseguendo la nostra stessa distribuzione utilizzando i nostri limiti di specifica. |
| |
Quindi, come potete vedere qui, abbiamo la nostra analisi della capacità di processo per entrambe le colonne. Questo è solo un esempio di come ottenere i limiti di specifica, ma lo stesso può essere applicato a qualsiasi proprietà di colonna che si desidera applicare e per la quale si desidera ottenere la sintassi in JSL. |
| |
Quindi il prossimo errore di cui parleremo è la manipolazione dei comandi di dispatch. Cos'è un comando di dispatch? |
| |
È ciò che appare nello script salvato quando si seleziona la finestra Salva nello script o Salva negli appunti dal menu con il triangolo rosso. |
| |
E appare quando si aggiunge qualcosa come una linea di riferimento o si modifica qualcos'altro, come la chiusura di una casella di contorno. Questo comando è stato sviluppato internamente a JMP per consentire la ricreazione dei grafici. |
| |
con la personalizzazione che hai apportato. E non era previsto che gli utenti |
| |
Personalizzalo con variabili dinamiche. Questo significa che alcuni degli argomenti nel comando dispatch non accettano variabili JSL. Vediamo un esempio di dove questo potrebbe accadere. Ecco uno script. Abbiamo un |
| |
tabella e una variabile stringa che useremo più avanti. E questo è essenzialmente ciò che verrebbe restituito dalla finestra di salvataggio nello script. Quindi, quando eseguiamo questo, |
| |
possiamo vedere che il nostro comando di invio imposta il minimo massimo e l'incremento per l'asse di misurazione |
| |
qui è impostato da zero a 1,4. Ora possiamo vedere che il comando di dispatch si basa su |
| |
Titolo della casella di riepilogo qui, ma quel titolo della casella di riepilogo si basa in realtà sul nostro input Y. Quindi, supponiamo di volere un input dinamico da parte di un utente e di avere questa variabile. Potremmo usare la variabile per Y. |
| |
Ma poi dovremmo anche usare il nome di quella colonna qui. Quindi, quando eseguiamo questo, vedrete che non otteniamo le impostazioni corrette degli assi da 0,4 a 1,2, il che non è... quindi significa che ciò che abbiamo inviato non è stato elaborato. |
| |
Ci sono un paio di modi per risolvere questo problema. Il primo è usare la soluzione dell'espressione di valutazione di cui Wendy ha parlato qualche minuto fa. Qui vedete che abbiamo la stessa espressione di valutazione. In realtà vogliamo racchiudere la concatenazione che abbiamo provato nell'esempio precedente. |
| |
Qui. |
| |
Quindi l'espressione eval dirà di valutare l'intera cosa. Quindi quando eseguiamo eval EXPR, |
| |
sostituisce semplicemente il tutto con la nostra stringa concatenata e poi, ricorda quando eseguiamo la valutazione, |
| |
Esegue quell'espressione. Quindi qui abbiamo da 0 a 1,4. Quindi questo è un modo. |
| |
Ma a volte può ancora diventare un po' complicato. E come dovresti manipolare quei comandi di dispatch, perché li stai ancora usando e devi sapere come funzionano. Quindi il modo più comune per farlo è rimuovere completamente questo comando di dispatch. |
| |
Quindi, usiamo quello che chiamiamo "display box subscripting". Quindi, eseguirò questo con il comando dispatch rimosso e avremo le impostazioni originali degli assi. |
| |
E poi quello che faremo, prima che non sappiamo bene come scriverlo, solo guardandolo, è... Andiamo su questa icona, questa casella di riepilogo, clicchiamo con il pulsante destro del mouse. |
| |
Modifica e mostra la struttura ad albero. Questo ci mostra la struttura ad albero del riquadro di visualizzazione all'interno di questo riquadro di contorno e, all'interno di questo riquadro di contorno, potete vedere che questo riquadro asse è quello che vogliamo modificare. Quindi, all'interno di questo riquadro di contorno si trova il riquadro asse uno. |
| |
Quindi possiamo scrivere il nostro script. Usiamo questa funzione di report per ottenere il livello di report della piattaforma, OBJ1. |
| |
Quindi applichiamo un indice per ottenere il titolo della casella di riepilogo che sappiamo dovrebbe essere, in base al nome della nostra colonna. |
| |
E poi all'interno di questo vogliamo...e vogliamo essere il più specifici possibile, in modo che se le cose dovessero cambiare in una futura versione di JMP avremo meno probabilità di avere problemi. |
| |
Quindi, all'interno di questo, vogliamo la casella dell'asse 1 ed è così che otteniamo quella casella dell'asse, e quindi possiamo prendere le stesse informazioni dal comando di invio e convertirle nei messaggi che inviamo alla casella dell'asse. |
| |
E poi puoi vedere qui che ora le impostazioni dei nostri assi vanno da zero a 1,4. |
| |
Un altro modo più potente per farlo è usare XPath. Fa la stessa cosa, ma può essere un po' più complicato, ma consente anche una maggiore flessibilità per le versioni future di JMP, perché è possibile utilizzare i dati sottostanti relativi a un box. |
| |
Quindi l'ultimo errore di cui parleremo è l'utilizzo esclusivo dello spazio dei nomi globale. Quindi |
| |
Potresti non saperlo, ma quando crei un simbolo senza specificare dove va, viene inserito nello spazio dei nomi globale. Quindi è ottimo per script rapidi quando stai solo simulando qualcosa per uso personale. |
| |
ma potrebbe non essere una buona idea per gli script che invii ai colleghi o per gli script che pubblichi o per i componenti aggiuntivi che pubblichi nella Community. |
| |
Ora qualche dettaglio in più su come funzionano l'ambito e la ricerca dei nomi in JMP. Si inizia dal basso in questo diagramma. L'ambito locale può essere un numero qualsiasi di ambiti, tra cui funzioni e box locali. |
| |
Quindi, oltre a ciò, se non trova il simbolo o non hai specificato di andare in locale a seconda che tu stia scrivendo o leggendo, |
| |
Poi c'è l'ambito here, che esiste essenzialmente uno per file. E c'è l'ambito globale, che essenzialmente è un ambito per la sessione di JMP. E poi, a destra, abbiamo l'ambito namespace, che è qualcosa che bisogna cercare esplicitamente per |
| |
accesso. Diamo un'occhiata a un esempio. Questo eliminerà tutti i miei simboli e, poiché non ho specificato dove dovrebbero andare, andranno nelle variabili globali. Quindi x è 5. Ma cosa succede se qualcun altro ha uno script che dice, beh, anch'io |
| |
avere un |
| |
La variabile x che voglio usare. E non specificherò dove posizionarla. Quindi la imposterò a 10. |
| |
Ma poi quando torni al tuo script e forse questa è una variabile che hai impostato e poi hai un callback su un pulsante...pulsante |
| |
un'azione che si basa su quella variabile, quindi la si usa e la variabile cambia e probabilmente questo non è desiderato. |
| |
Quali sono alcuni modi per risolvere questo problema? Beh, il modo più semplice è usare i nomi impostati di default su here(1). Questo significa che nulla finirà nell'ambito globale, a meno che non venga specificato esplicitamente. Diamo un'occhiata. |
| |
a questo |
| |
Esempio. Quindi tutto quello che abbiamo fatto è stato aggiungere questo nome predefinito qui(1). Può andare con... in genere va all'inizio dello script, ma può andare ovunque. |
| |
Vado, pulirò i miei simboli e imposterò questa variabile x uguale a 5. Quindi abbiamo altre scritture qui che sono |
| |
Dice che voglio accedere al tuo, al tuo x. Ma in realtà questo x non può mai accedere a questo x in questo namespace qui. Quindi |
| |
copiamo una parte dello script e scriviamo X uguale a 50. |
| |
E quindi la X nella scrittura a destra è 50, ma questo non ha avuto alcun effetto sulla X nella nostra scrittura a sinistra. Ecco, questo è un ottimo modo per separare facilmente i simboli da altri script e applicazioni. |
| |
L'altra opzione è usare uno spazio dei nomi personalizzato. È un po' più avanzato, ma può essere molto potente. Quindi eccomi di nuovo qui... cancella il mio |
| |
simboli e poi creare un nuovo namespace, impostare una variabile x al suo interno e visualizzarla. Quindi ha un valore di cinque. |
| |
E hai un altro copione qui. Forse questo è uno dei tuoi copioni e lo sai |
| |
myNS esiste. Quindi puoi provare ad accedervi, e puoi farlo senza problemi, perché ne conosci il nome. Ma è molto meno probabile che qualcuno di malintenzionato cambi il tuo simbolo a tua insaputa. Quindi |
| |
Posso modificare questo simbolo e sarà sempre 10, ma se faccio solo X, non avrà alcun effetto sul risultato della X dallo spazio dei nomi. |
| |
Ora passo la parola a Wendy, che ci parlerà di alcune risorse trascurate. |
| wendymurphrey |
Grazie, Justin. Ci sono molte risorse disponibili per saperne di più su JSL, molte delle quali sono gratuite. Qui abbiamo linkato alcuni dei siti più comuni dove cercare e approfondire la conoscenza di JSL. |
| |
Offriamo anche supporto tecnico a cui potete rivolgervi e abbiamo anche un paio di libri sull'argomento. Naturalmente, vi invitiamo sempre a dare un'occhiata alle nostre risorse di formazione e ai programmi che hanno preparato per voi. |
| |
Assicuratevi di dare un'occhiata al documento associato a questa presentazione sulla community JMP, poiché contiene alcuni altri errori che abbiamo trattato lì, ma che non abbiamo avuto il tempo di discutere oggi. Grazie per aver guardato. |
