La sortie est :
Contient(collist, col) = 0 ;
Contient(collist, As Name(colname)) = 1 ;
Re : Pourquoi ces méthodes de référencement des colonnes donnent-elles des résultats différents ?Cette expression ne stocke pas de référence de colonne :
col = AsName("abc");
La fonction Contient() renvoie donc 0 (faux).Vous devez utiliser Column( "name" ) si vous souhaitez stocker une référence de colonne.
Re : Pourquoi ces manières de référencer les colonnes donnent-elles des résultats différents ?Un terrier de lapin virtuel à venir. La réponse de Mark est peut-être tout ce dont vous avez besoin.
C'est une question fascinante. Il semble bien que vous devriez obtenir la même réponse, mais...
Contrairement au C et à de nombreux autres langages, les arguments des fonctions ne sont pas évalués avant l'appel de la fonction. Au lieu de cela, la fonction détermine comment gérer ses paramètres. Et JSL a un type de variable appelé expression, étroitement lié à la valeur renvoyée par AsName. Lorsque vous appelez une fonction avec un argument d'expression, la fonction peut choisir quoi faire avec le paramètre. Il pourrait évaluer l'expression ; a+2 nécessite de rechercher la variable a et d'ajouter 2. Ou cela peut manipuler l'expression ; head(a+2) renvoie add . Dans votre exemple, l'expression est abc , et la rechercher signifie obtenir sa valeur à partir d'une ligne de la table de données.
(C'est difficile, j'ai passé une heure à essayer de rendre les commentaires corrects et clairs. Je pense qu'ils sont corrects.)
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;
enfin,
Show( Name Expr( col ), Type( col ), Contains( collist, Name Expr(col) ) );
fait ce que tu veux; le 2ème argument de contain() a le wrapper nameexpr() qui amène contain() à l'évaluer avec le nom de l'expression, abc , pas la valeur.
edit : ce n'est jamais facile ! @hogi souligne que l'exemple head(a+2) (ci-dessus) est faux dans Head évalue-t-il son argument ? ; Je pense que la réponse est head() jette un coup d'œil à l'argument pour voir s'il s'agit d'une variable contenant une expression, et sinon, l'évalue pour voir si elle produira une expression.
Pourquoi ces façons de référencer les colonnes donnent-elles des résultats différents ?J'ai du mal à comprendre comment JSL gère les références de colonne et continue de rencontrer des bogues dans mes scripts pour cette raison.
Pourquoi les expressions suivantes donnent-elles des résultats différents ?
Quelle est la meilleure façon de transmettre dynamiquement des références de colonne à des fonctions ?
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)));La sortie est :
Contains(collist, col) = 0;
Contains(collist, As Name(colname)) = 1;
Automatisation et scriptRe : Pourquoi ces manières de référencer les colonnes donnent-elles des résultats différents ?@Craige_Hales .
Merci pour cet article - je l'ajouterai à ma liste de trésors 
Cela donne une idée de pourquoi Nom Expr (Comme colonne (nom de colonne))
[par exemple par @jthi dans Re : Besoin d'aide avec les expressions, les références de colonnes, les formules et le renommage des colonnes ] est tellement utile !
J'aurais aimé dire : je pense que je comprends vraiment maintenant - mais certains des résultats ci-dessous me surprennent encore.
Je suis toujours à la recherche d'une documentation complète - par exemple, comment le savoir comment une fonction gère ses paramètres.
Lors d'une recherche via contient , pourquoi Jmp le sait-il Colonne("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
