Die Ausgabe ist:
Enthält (Kollist, Spalte) = 0;
Contains(collist, As Name(colname)) = 1;
Betreff: Warum liefern diese Arten der Spaltenreferenzierung unterschiedliche Ergebnisse?Dieser Ausdruck speichert keine Spaltenreferenz:
col = AsName("abc");
Die Contains()-Funktion gibt also 0 (falsch) zurück.Sie sollten Column( "name" ) verwenden, wenn Sie eine Spaltenreferenz speichern möchten.
Betreff: Warum führen diese Arten der Spaltenreferenzierung zu unterschiedlichen Ergebnissen?Vor uns liegt ein virtueller Kaninchenbau. Marks Antwort könnte alles sein, was Sie brauchen.
Ist eine faszinierende Frage. Es sieht sicher so aus, als ob Sie die gleiche Antwort bekommen sollten, aber ...
Im Gegensatz zu C und vielen anderen Sprachen werden die Argumente von Funktionen nicht ausgewertet, bevor die Funktion aufgerufen wird. Stattdessen bestimmt die Funktion, wie mit ihren Parametern umgegangen wird. Und JSL verfügt über einen Variablentyp namens expression, der eng mit dem Wert zusammenhängt, den AsName zurückgibt. Wenn Sie eine Funktion mit einem Ausdrucksargument aufrufen, kann die Funktion auswählen, was mit dem Parameter geschehen soll. Es könnte den Ausdruck auswerten; a+2 erfordert das Nachschlagen der Variablen a und das Hinzufügen von 2. Oder es könnte den Ausdruck manipulieren; head(a+2) gibt add zurück. In Ihrem Beispiel ist der Ausdruck abc und das Nachschlagen bedeutet, dass der Wert aus einer Zeile in der Datentabelle abgerufen wird.
(Das ist schwierig, ich habe eine Stunde damit verbracht, die Kommentare korrekt und klar zu formulieren. Ich denke, sie sind korrekt.)
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;
Endlich,
Show( Name Expr( col ), Type( col ), Contains( collist, Name Expr(col) ) );
macht, was Sie wollen; Das 2. Argument von enthält () hat den Wrapper nameexpr (), der bewirkt, dass enthält () es anhand des Namens des Ausdrucks, abc , und nicht des Werts auswertet.
Edit: Das ist nie einfach! @hogi weist darauf hin, dass das Beispiel head(a+2) (oben) falsch ist: Bewertet Head sein Argument? ; Ich denke, die Antwort ist, dass head() einen Blick auf das Argument wirft, um zu sehen, ob es eine Variable ist, die einen Ausdruck enthält, und wenn nicht, es auswertet, um zu sehen, ob es einen Ausdruck erzeugt.
Warum führen diese Arten der Spaltenreferenzierung zu unterschiedlichen Ergebnissen?Ich habe Schwierigkeiten zu verstehen, wie JSL mit Spaltenverweisen umgeht, und stoße aus diesem Grund immer wieder auf Fehler in meinen Skripten.
Warum liefern die folgenden Ausdrücke unterschiedliche Ergebnisse?
Was ist der beste Weg, Spaltenverweise dynamisch an Funktionen zu übergeben?
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)));Die Ausgabe ist:
Contains(collist, col) = 0;
Contains(collist, As Name(colname)) = 1;
Automatisierung und SkripterstellungBetreff: Warum führen diese Arten der Spaltenreferenzierung zu unterschiedlichen Ergebnissen?@Craige_Hales .
Vielen Dank für diesen Beitrag – ich werde ihn meiner Schatzliste hinzufügen 
Es gibt einen Hinweis darauf, warum Name Expr(As Column(colname))
[zB von @jthi In Betreff: Benötigen Sie Hilfe bei Ausdrücken, Spaltenverweisen, Formeln und Spaltenumbenennungen? ] ist so nützlich!
Ich hätte gerne gesagt: Ich glaube, ich verstehe es jetzt wirklich – aber einige der folgenden Ergebnisse überraschen mich immer noch.
Ich bin immer noch auf der Suche nach einer ausführlichen Dokumentation, z. B. wie ich das herausfinden kann Wie Eine Funktion verwaltet ihre Parameter.
Bei der Suche über enthält , warum weiß Jmp das? Spalte("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
