La salida es:
Contiene(collista, col) = 0;
Contiene (collist, As Name (colname)) = 1;
Re: ¿Por qué estas formas de referenciar columnas dan resultados diferentes?Esta expresión no almacena una referencia de columna:
col = AsName("abc");
Entonces la función Contiene() devuelve 0 (falso).Debe usar la columna ("nombre") si desea almacenar una referencia de columna.
Re: ¿Por qué estas formas de hacer referencia a columnas dan resultados diferentes?Una madriguera de conejo virtual más adelante. La respuesta de Mark puede ser todo lo que necesitas.
Es una pregunta fascinante. Seguro que parece que deberías obtener la misma respuesta, pero...
A diferencia de C y muchos otros lenguajes, los argumentos de las funciones no se evalúan antes de llamar a la función. En cambio, la función determina cómo manejar sus parámetros. Y JSL tiene un tipo de variable llamado expresión, estrechamente relacionado con el valor que devuelve AsName. Cuando llamas a una función con un argumento de expresión, la función puede elegir qué hacer con el parámetro. Podría evaluar la expresión; a+2 requiere buscar la variable a y sumar 2. O podría manipular la expresión; head(a+2) devuelve agregar . En su ejemplo, la expresión es abc y buscarla significa obtener su valor de una fila en la tabla de datos.
(Esto es difícil, pasé una hora tratando de que los comentarios fueran correctos y claros. Creo que son correctos).
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) ) );
hace lo que quieres; el segundo argumento de contiene() tiene el contenedor nameexpr() que hace que contiene() lo evalúe según el nombre de la expresión, abc , no el valor.
Editar: ¡esto nunca es fácil! @hogi señala que el ejemplo de head(a+2) (arriba) es incorrecto en ¿Head evalúa su argumento? ; Creo que la respuesta es head() echa un vistazo al argumento para ver si es una variable que contiene una expresión y, si no, lo evalúa para ver si producirá una expresión.
¿Por qué estas formas de hacer referencia a las columnas dan resultados diferentes?Estoy luchando por entender cómo JSL maneja las referencias de columna y sigo encontrando errores en mis scripts por ese motivo.
¿Por qué las siguientes expresiones dan resultados diferentes?
¿Cuál es la mejor manera de pasar dinámicamente referencias de columna a funciones?
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 salida es:
Contains(collist, col) = 0;
Contains(collist, As Name(colname)) = 1;
Automatización y secuencias de comandosRe: ¿Por qué estas formas de hacer referencia a columnas dan resultados diferentes?@Craige_Hales .
Gracias por esta publicación. La agregaré a mi lista de tesoros 
Da alguna pista de por qué Nombre Expr (como columna (nombre de columna))
[por ejemplo, por @jthi en Re: Necesita ayuda con expresiones, referencias de columnas, fórmulas y cambio de nombre de columnas ] ¡Es muy útil!
Me hubiera gustado decir: creo que ahora lo entiendo realmente, pero algunos de los resultados que aparecen a continuación todavía me sorprenden.
Todavía estoy buscando una documentación completa, por ejemplo, cómo averiguarlo. cómo una función maneja sus parámetros.
Al buscar a través de contiene ¿Por qué Jmp sabe eso? Columna("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
