L'uscita è:
Contiene(collist, col) = 0;
Contiene(collist, As Name(colname)) = 1;
Ri: Perché questi modi di fare riferimento alle colonne danno risultati diversi?Questa espressione non memorizza un riferimento di colonna:
col = AsName("abc");
Quindi la funzione Contains() restituisce 0 (false).Dovresti usare Column( "name" ) se vuoi memorizzare un riferimento di colonna.
Ri: Perché questi modi di fare riferimento alle colonne danno risultati diversi?Tana del coniglio virtuale più avanti. La risposta di Mark potrebbe essere tutto ciò di cui hai bisogno.
È una domanda affascinante. Sembra proprio che dovresti ottenere la stessa risposta, ma...
A differenza del C e di molti altri linguaggi, gli argomenti delle funzioni non vengono valutati prima che la funzione venga chiamata. Invece la funzione determina come gestire i suoi parametri. Inoltre, JSL ha un tipo di variabile chiamato espressione, strettamente correlato al valore restituito da AsName. Quando chiami una funzione con un argomento di espressione, la funzione può scegliere cosa fare con il parametro. Potrebbe valutare l'espressione; a+2 richiede la ricerca della variabile a e l'aggiunta di 2. Oppure potrebbe manipolare l'espressione; head(a+2) restituisce add . Nel tuo esempio, l'espressione è abc e cercarla significa ottenere il suo valore da una riga nella tabella dati.
(È difficile, ho passato un'ora cercando di rendere i commenti corretti e chiari. Penso che siano corretti.)
dt = New Table( "test", New Column( "abc" ), New Column( "def" ) );
collist = {:abc, :def, .}; // <<< added a missing value in position 3
col = As Name( "abc" );// the Right Hand Side evaluates to the expression abc,
// and the expression is assigned to col. The 2nd argument to contains() is
// a name expression, and contains() evaluates that argument. It
// evaluates to missing because there is no subscript to pick a row.
Show( Name Expr( col ), Type( col ), Contains( collist, col ) ); // looks for a missing value
// Name Expr(col) = abc;
// Type(col) = "Number";
// Contains(collist, col) = 3;
colname = "abc";
// contains() evaluates the 2nd argument to a name, but does not
// do another evaluation of the name, so it locates the name
// in the list of names
Show( Type( As Name( colname ) ), Contains( collist, As Name( colname ) ) );
// Type(As Name(colname)) = "Name";
// Contains(collist, As Name(colname)) = 1;
Finalmente,
Show( Name Expr( col ), Type( col ), Contains( collist, Name Expr(col) ) );
fa quello che vuoi; il 2° argomento di contiene() ha il wrapper nameexpr() che fa sì che contiene() lo valuti sul nome dell'espressione, abc , non sul valore.
edit: non è mai facile! @hogi sottolinea che l'esempio head(a+2) (sopra) è sbagliato in Head valuta il suo argomento? ; Penso che la risposta sia head() che dà una sbirciatina all'argomento per vedere se si tratta di una variabile che contiene un'espressione e, in caso contrario, la valuta per vedere se produrrà un'espressione.
Perché questi modi di fare riferimento alle colonne danno risultati diversi?Faccio fatica a capire come JSL gestisce i riferimenti alle colonne e per questo motivo continuo a imbattermi in bug nei miei script.
Perché le seguenti espressioni danno risultati diversi?
Qual è il modo migliore per passare dinamicamente i riferimenti di colonna alle funzioni?
dt = New Table("test",
New Column("abc"),
New Column("def")
);
collist = {:abc, :def};
col = AsName("abc");
colname = "abc";
Show(Contains(collist, col));
Show(Contains(collist, AsName(colname)));L'uscita è:
Contains(collist, col) = 0;
Contains(collist, As Name(colname)) = 1;
Automazione e scriptingRi: Perché questi modi di fare riferimento alle colonne danno risultati diversi?@Craige_Hales .
Grazie per questo post, lo aggiungerò alla mia lista dei tesori 
Fornisce qualche suggerimento sul perché Nome Espr(Come colonna(colname))
[ad esempio da @jthi In Ri: Hai bisogno di aiuto con espressioni, riferimenti a colonne, formule e ridenominazione di colonne ] è così utile!
Avrei voluto dire: penso di aver capito davvero adesso, ma alcuni dei risultati seguenti mi sorprendono ancora.
Sto ancora cercando una documentazione completa, ad esempio come scoprirlo Come una funzione gestisce i suoi parametri.
Durante la ricerca tramite contiene , perché Jmp lo sa Colonna("abc") = :abc?
dt = New Table( "test", New Column( "abc" ), New Column( "def" ) );
collist = {:abc, :def, .}; // <<< added a missing value in position 3
row()=0; //to be sure that the row index is really 0 :)
colname = "abc";
col = As Name( colname); // abc
col2 = :name("abc"); // .
col3 = As Column(colname); // .
col4 = Name Expr(As Column(colname)); // :abc
col5 = Column(colname); // Column("abc")
col6 = Name Expr(Column(colname)); // Column( colname )
col; // .
col2; // .
col3; // .
col4; // .
col5; // Column( "abc" )
col6; // Column( "abc" )
Show( Name Expr( col ), Type( col ), Contains( collist, col ) ); // :abc, Number, 3
Show( Name Expr( col2 ), Type( col2 ), Contains( collist, col2 ) ); // . , Number, 3
Show( Name Expr( col3 ), Type( col3 ), Contains( collist, col3 ) ); // ., Number, 3
Show( Name Expr( col4 ), Type( col4 ), Contains( collist, col4 ) ); // :abc, Number, 3
Show( Name Expr( col5 ), Type( col5 ), Contains( collist, col5 ) ); // Column("abc"), Column, 1 (!)
Show( Name Expr( col6 ), Type( col6 ), Contains( collist, col6 ) ); // Column(colname), Column, 1 (!!)
Show( Contains( collist, Name Expr(col) ) ); // 1
Show( Contains( collist, Name Expr(col2) ) ); // 3
Show( Contains( collist, Name Expr(col3) ) ); // 3
Show( Contains( collist, Name Expr(col4) ) ); // 1
Show( Contains( collist, Name Expr(col5) ) ); // 1
Show( Contains( collist, Name Expr(col6) ) ); // 0
