runmany
1.0.0
Intro | Installation | Verwendung | Syntax | Einstellungen | Um
Ein Tool zum Ausführen von vielen Programmen, die in vielen Sprachen aus einer Datei geschrieben wurden.
Normalerweise benötigen Sie mehrere Programmiersprachen, sobald Sie mehrere Dateien oder mehrere Projekte benötigen, möglicherweise mehrere IDEs. RunMany ist ein Tool, mit dem Sie mehrere Programme mit den gewünschten Programmiersprachen in dieselbe Datei schreiben und sie dann alle auf einmal ausführen können.
RunMany verwendet ".many" als Dateierweiterung, beispielsweise, wenn eine Datei namens simple.many den folgenden Inhalt hat:
Python:
print("Hi")
JavaScript:
console.log("Hi")
C:
#include <stdio.h>
int main() {
printf("Hin");
return 0;
}
Dann erzeugt runmany simple.many im Terminal diese organisierte Ausgabe des Ausführens der Programme Python, JavaScript und C -Programme innerhalb:
************************************************************
1. Python
-------------------- output from line 1 --------------------
Hi
************************************************************
2. JavaScript
-------------------- output from line 4 --------------------
Hi
************************************************************
3. C
-------------------- output from line 7 --------------------
Hi
************************************************************
3/3 programs successfully run!
3/3 had the exact same stdout!
************************************************************
ARGV und STDIN können auch in der .many-Datei pro Sprache angegeben werden, und es gibt viele Einstellungen, mit denen die Sprachen ausgeführt und in der Ausgabe angezeigt werden.
Im Allgemeinen kann RunMany für:
Gesamterstrang ist ein nützliches Werkzeug für alle, die gleichzeitig mit mehreren Programmiersprachen spielen möchten.
Stellen Sie sicher
pip install runmany
in Terminal zur Installation des neuesten Runmany Python -Pakets von PYPI. Dann sollte runmany <filename> für die Ausführung von .many -Dateien arbeiten. Weitere Möglichkeiten, um in der Verwendung zu laufen.
RunMany arbeitet am besten in VSCODE mit der Companion RunMany VSCODE -Erweiterung, die Syntax -Hervorhebung für .many -Dateien und schnelle Möglichkeiten zum Ausführen bietet. Installieren Sie die Erweiterung kostenlos vom Marktplatz oder durch Ausführen:
code --install-extension discretegames.runmany
Sie benötigen auch die Programmiersprachen, die RunMany auf Ihrem Computer installiert werden sollen, da RunMany ihre Dolmetscher/Compiler hinter den Kulissen verwendet, um Programme auszuführen.
Runmany hat integrierte Unterstützung für die folgenden Sprachen:
Ada, Bash, Batch, C, C#, C++, Dart, Fortran, Go, Groovy, Haskell, Java, JavaScript, Julia, Kotlin, Lisp, Lua, MIPS, Pascal, Perl, PHP, PowerShell, Print, Python, Python 2, R, Racket, Ruby, Rust, Scala, TypeScript, VBScript, and Visual Basic
Wenn Sie bereits eine dieser Sprachen installiert haben, besteht eine gute Chance, dass es in Runmany automatisch funktioniert.
Die RunMany VSCODE -Erweiterung bietet Syntax -Hervorhebung für all diese Sprachen sowie einige weitere.
Es gibt Möglichkeiten, benutzerdefinierte Sprachen hinzuzufügen und das Verhalten integrierter Sprachen zu ändern und sie auf verschiedenen Betriebssystemen sogar unterschiedlich zu machen. Weitere Informationen finden Sie unter Anpassen von Sprachen.
Beachten Sie, dass Print eine Versorgungssprache ist, die den Codeinhalt einfach in STDOut druckt, und MIPS erwartet, dass mars.jar im aktuellen Arbeitsverzeichnis liegt.
Wenn pip install runmany nicht funktioniert hat, versuchen Sie pip3 install runmany oder python -m pip install runmany oder python3 -m pip install runmany .
Wenn bei Windows nichts funktioniert, müssen Sie möglicherweise sicherstellen, dass sich die Verzeichnisse der Python -Installation und der Skripts in Ihrer Pfadumgebungsvariable befinden, dann Ihr Terminal neu starten und erneut versuchen.
Runmany wurde in Python 3.9 unter Windows hergestellt und auf Python -Versionen 3.6, 3.7, 3.8, 3.9 und 3.10 unter Windows gründlich getestet. Es sollte auch bei Linux und MacOS gut funktionieren, wurde jedoch weniger ausführlich auf diesen Betriebssystemen getestet, insbesondere wenn es um die Befehle geht, die die Dolmetscher/Compiler anderer Programmiersprachen ausführen.
RunMany ist jetzt in Version 2 mit einer verbesserten .many -Datei -Syntax und weiteren Einstellungen. Die alte Version 1.0.3 ist noch auf PYPI erhältlich.
Um eine Runmany -Datei namens myfile.many zu führen.
runmany myfile.many
Es gibt auch optionale Argumente, um Hilfe zu erhalten und die Einstellungen und Ausgabedateien anzugeben:
runmany [-h --help] [-s --settings <settings-file>] [-o --outfile <output-file>] <input-file>
<input-file> ist die erforderliche. Many-Datei zum Ausführen.<settings-file> ist die optionale .json-Datei, die definiert, wie Sprachen ausgeführt werden und wie die Ausgabe formatiert wird.<output-file> ist die optionale Datei, mit der die Ausgabe an gesendet wird. Nach weggelassener Ausgabe geht die Ausgabe an stdout. Beispielsweise wäre der Befehl zum Ausführen myfile.many mit Einstellungen mysettings.json und Senden von Output an myoutput.txt :
runmany -s mysettings.json -o myoutput.txt myfile.many
Wenn in der Befehlszeile eine Einstellungsdatei bereitgestellt wird, werden alle Einstellungsabschnitte in der Eingabedatei ignoriert. Wenn weder vorhanden sind noch für fehlende Einstellungen, wird default_setings.json als Fallback verwendet. Weitere Informationen finden Sie in Einstellungen.
Für einige Beispiele für .many -Dateien und deren Ausgabe überprüfen Sie den Beispiel -Ordner auf GitHub oder das ManyChallenges Repo, in dem verschiedene Code -Herausforderungen für Websites wie Project Euler in vielen Sprachen gleichzeitig gelöst werden.
Die .many -Erweiterung für RunMany -Dateien ist nicht erforderlich, sondern für Klarheit empfohlen.
RunMany kann wie folgt von Python importiert und verwendet werden:
from runmany import runmany , runmanys
# Run to stdout
runmany ( 'path/to/myfile.many' , 'path/to/mysettings.json' ) # settings JSON is always optional
# Run to output file
runmany ( 'path/to/myfile.many' , 'path/to/mysettings.json' , 'path/to/myoutput.txt' )
# Run to file object
with open ( 'path/to/myoutput.txt' , 'w' ) as output_file :
runmany ( 'path/to/myfile.many' , 'path/to/mysettings.json' , output_file )
# Run to string
output_string = runmanys ( 'path/to/myfile.many' , 'path/to/mysettings.json' )
print ( output_string ) Sowohl in runmany.runmany als auch runmany.runmanys -Funktionen wird from_string=True das .many-Dateiargument als Zeichenfolge anstelle eines Dateipfads interpretiert, und das Einstellungsargument kann als Pfad zur .json-Datei oder als JSON-ähnlicher Python-Dictionary oder None Einstellungen angegeben werden. Wie beim Ausführen aus der Befehlszeile werden die Einstellungen hier die in der .many -Datei eingebetteten Einstellungen ignoriert.
Die Funktion runmany.cmdline , die eine Liste von Befehlszeilenargumenten enthält, ist ebenfalls als Alternative zur direkten Verwendung der Befehlszeile vorhanden.
Das .many -Dateiformat ist das, was Runmany erwartet, wenn eine Datei ausgeführt wird.
Vor allem eine .many -Datei besteht aus Abschnitten, die jeweils eine oder mehrere Snippets enthalten. Ein Abschnitt beginnt mit einer uneingeschränkten Header -Linie wie Python: oder Stdin for Python: Dann erscheint der Inhalt des ersten Snippets nach dem Dickdarm und auf eingedrungenen Zeilen unten. In dem Abschnitt können zusätzliche Ausschnitte mit einem uneinheitlichen Also: Header hinzugefügt werden und ein Abschnitt endet, wenn ein neuer Start oder ein uneingeschränktes End. oder das Ende der Datei ist erreicht.
Eine .many -Datei wird von oben nach unten ausgeführt, wobei Abschnitte und Snippets in der Reihenfolge ausführt, in der sie auftreten. Insbesondere wird eine .many -Datei ausgeführt, unabhängig davon, ob sie Syntaxfehler enthält oder nicht. Jede ungültige Syntax wird in einer Fehlermeldung ignoriert und erwähnt.
bar baz folgenden Stdin for Python: in der Python: print('foo' + input()) Durch das Ausführen dieser Datei wird das Python -Programm zweimal, einmal für bar und einmal für baz ausgeführt, wodurch die jeweiligen Ausgänge foobar und foobaz verleiht.
Stdin for Python:
bar
Also:
baz
End.
Python:
print('foo' + input())
End.
Lesen Sie weiter für Einzelheiten zu allen .many -Datei -Syntax oder lesen Sie Syntax.many, die auch Beispiele für alle Syntaxe enthält.
%% als erste Nicht-Whitespace-Zeichen in einer Zeile macht bis zum Ende dieser Zeile einen Kommentar.
%% this is a comment
Python: %% this is not a comment
%% this is a comment
print(1) %% this is not a comment
Es gibt keine Block -Kommentare, obwohl Start & Stop in der Funktionalität eng sind.
Wie bereits erwähnt, besteht eine .many -Datei aus Abschnitten, die mit einem Header beginnen und Snippets enthalten. Es gibt vier Arten von Abschnitten:
<language>: oder <language1>, <language2>, ...:Argv: oder Argv for <language1>, <language2>, ...:Stdin: oder Stdin for <language1>, <language2>, ...:Settings: Alle Abschnitt mit den Einstellungen können eine von der Kommas getrennte Liste der Sprachen haben, für die sie im Header gilt. Diese Sprachen, die einst von der Whitespace gestreift wurden, müssen den "name" der Sprachen in den Einstellungen JSON übereinstimmen, sind jedoch nicht sensibel. (Schlüsselwörter wie "Argv" und "stdin" sind Fall sensibel. Benutzerdefinierte Sprachen sollten weder RunMany -Schlüsselwörter als Namen verwenden noch die Zeichen enthalten ,:%!@ .)
Der Header Also: Wird verwendet, um einem Abschnitt und End. kann optional verwendet werden, um einen Abschnitt zu beenden.
Der Inhalt eines Snippetes ist der Text nach jeder Whitespace nach dem Dickdarm ( : im Snippet -Header sowie alle darunter liegenden Linien, die mit einer einzelnen Lasche oder 4 Leerzeichen (mit diesen Einständen entfernt) eingedrungen sind, bis zum nächsten Header oder End. oder Ende der Datei.
Also dieser Code -Abschnitt
Python: import math
print(math.pi)
Also: print('pie')
print('cake')
hat zwei Ausschnitte, deren Inhalt ist:
import math
print ( math . pi ) print ( 'pie' )
print ( 'cake' )Leere Zeilen über oder unterhalb der Abschnitte dienen nur zur Lesbarkeit und nicht erforderlich. Der unkontrollierte Code außerhalb der Abschnitte ist ungültig.
Ein Code -Abschnitt beginnt mit einer von Kommas getrennten Liste von Sprachen und der Snippet -Inhalt sind die Programme, die in diesen Sprachen ausgeführt werden sollen.
Eine Sprache in der von Kommas getrennten Liste ist fast immer ausreichend, es sei denn, Sie schreiben Polyglots,
JavaScript:
console.log('Some code that will be run in JavaScript.')
Python, Python 2:
print('Some code that will be run in Python 3 then Python 2.')
Also:
print('Some more code that will be run in Python 3 then Python 2.')
Also: Snippet -Header in Codeabschnitten sind eine Kurzform für die Wiederholung des Abschnitts -Headers.
Argv ist der Argumentvektor, auch bekannt als die an Programme gesendeten Befehlszeilenargumente.
Ein ARGV -Abschnitt kann entweder Argv: sich für alle Sprachen zu bewerben oder Argv for <language1>, <language2>, ...: Um sich auf die Sprachen in der Liste der von Kommas getrennten zu bewerben. In beiden Fällen überschreibt ein früherer Argv -Set für diese Sprachen.
Jeder Snippet in einem ARGV -Abschnitt ist ein separates Argv, das wiederum an die Programme der Sprachen gesendet wird, auf die der Abschnitt angewendet wird. Dies erleichtert es einfach, viele Argvs gleichzeitig zu testen.
Argv: argv sent to all languages
Argv for Python: 1
Also: 2
Also: 3
Python:
import sys
print(sys.argv[1])
Dieser .many Code wird das Python -Programm dreimal mit ARGV 1 dann ausführen, dann 2 dann 3 .
Damit ARGV arbeitet, muss der $argv -Platzhalter ordnungsgemäß in den Befehl der Sprache eingebaut werden.
Fast genau wie ein ARGV -Abschnitt, aber für den Standard -Eingabestream -Benutzern tippen normalerweise Text in den Text ein.
Ein STDIN -Abschnitt kann entweder Stdin: sich für alle Sprachen zu bewerben oder Stdin for <language1>, <language2>, ...: Um sich für die Sprachen in der von der Kommas getrennten Liste zu bewerben. In beiden Fällen überschreibt ein früheres Stdin -Set für diese Sprachen.
Jeder Snippet in einem Stdin -Abschnitt ist ein separates Stdin, das wiederum an die Programme der Sprachen gesendet wird, auf die der Abschnitt angewendet wird. Dies erleichtert es einfach, viele Stdins gleichzeitig zu testen.
Stdin: stdin sent to all languages
Stdin for Python: A
Also: B
Also: C
Python:
print(input())
Dieser .many Code wird das Python -Programm dreimal mit Stdin A ausgeführt, dann B dann C .
Wenn mehrere Argvs und Stdins für eine Sprache gelten, werden alle möglichen Kombinationen jedes Argv und jedes Stdin an Programme dieser Sprache gesendet.
Ein Einstellungsabschnitt beginnt mit Settings: und ermöglicht das Einbetten eines Einstellungen JSON in eine .many -Datei, die verwendet wird, bis ein Abschnitt Einstellungen auftritt.
Diese eingebetteten Einstellungen werden nur verwendet, wenn die Einstellungen nicht speziell bereitgestellt wurden, wenn Runmany aufgerufen wurde. Fehlende Einstellungen standardmäßig in default_setings.json.
Settings:
{ "show_code": true }
Python:
print('this Python code will now be shown as part of the output')
Eine JSON -Zeichenfolge des Pfads zu einer Einstellungsdatei kann ebenfalls verwendet werden, z. B. Settings: "path/to/mysettings.json" .
Also: Snippet -Header in Einstellungsabschnitten sind eine Kurzform für die Wiederholung des Abschnitts -Headers. Sie erfüllen also nicht viel Zweck, da sie die vorherigen Einstellungen sofort überschreiben.
Puting !! Zu Beginn eines Abschnitts deaktiviert Header den gesamten Abschnitt und alle Ausschnitte.
Putten ! Zu Beginn eines Snippet -Headers deaktiviert dieser Ausschnitt.
!!Python:
print('this is disabled')
Also:
print('this is also disabled')
!Python:
print('this is disabled')
Also:
print('this is not disabled')
!Also:
print('this is disabled')
Wenn ein Abschnittskopf mit @@ beginnen, werden nur diese Abschnitte ausgeführt, ähnlich wie bei einem "Solo" -Kontrok in der Audio-/Video -Bearbeitungssoftware.
Wenn Snippet -Header in einem Abschnitt mit @ beginnen, werden nur diese Snippets ausgeführt, wenn der Abschnitt ausgeführt wird.
@@@Python:
print('this is run')
Also:
print('this is not run')
@Also:
print('this is run')
Python:
print('this is not run')
@Also:
print('this is also not run')
Beachten Sie, wie die erste Zeile drei @@@ , zwei, um den Abschnitt zu Solo und ein weiteres zu Solo, um den ersten Snippet zu Solo zu Solo.
Alles vor dem letzten START: Zu Beginn einer Zeile selbst in einer .many -Datei wird ignoriert.
Alles nach dem ersten STOP. Zu Beginn einer Zeile selbst in einer .many -Datei wird ignoriert.
Daher wird nur der JavaScript -Abschnitt dieser .many -Datei ausgeführt:
Python: print('unseen')
START:
JavaScript: console.log('seen')
STOP.
Python: print('unseen')
Es sollte nur bis zu einem START: und ein STOP. in einer .many -Datei.
Die Einstellung von RunMany wird durch eine JSON -Datei definiert, die bereitgestellt werden kann, wenn RunMany aufgerufen oder direkt in eine .many -Datei eingebettet wird.
Die Einstellungen JSON definieren, was Sprachen Runmany ausführen können und wie sie sie ausführen werden. Es definiert auch, wie die Runmany -Ausgabe formatiert wird.
Die Datei default_Settings.json enthält die Standardwerte für alle Einstellungen. Diese Standardeinstellungen werden automatisch verwendet, wenn sie nicht in einer bereitgestellten oder eingebetteten Einstellungen JSON vorhanden sind.
Die meisten Einstellungen sind einfache Flags oder Werte, die in den Basiseinstellungen JSON -Objekt eingestellt werden können, um sie global anzuwenden (siehe Liste der Einstellungen), aber vier spezielle Schlüssel im JSON werden verwendet, um die Sprachen anzupassen, die RunMany ausführen oder weitere Sprachen hinzufügen kann. Dies sind "languages" , "languages_windows" , "languages_linux" und "languages_mac" ( "languages_<os>" werden verwendet, um auf die letzten drei zu verweisen). Sie sind Arrays von JSON-Objekten auf einstufig, die die Einstellungen für die Sprache angeben, die mit der Taste "name" des Objekts entspricht.
Das Array "languages_<os>" , das dem System-Betriebssystem entspricht, hat die höchste Priorität bei der Ermittlung der Einstellungen einer Sprache, gefolgt von dem Array "languages" , gefolgt von den integrierten "supplied_languages_<os>" und "supplied_languages" -Arrays. (Diese "supplied_languages..." -Arrays sollten niemals in Ihren Einstellungen eingestellt werden.) Sprachen verwenden die Einstellungen im Basis -JSON -Objekt als endgültiger Fallback.
Beispielsweise legt die folgenden Einstellungen JSON die Einstellung "show_code" (die standardmäßig falsch ist) für alle Sprachen auf, mit Ausnahme von Python und Python.
{
"show_code" : true ,
"languages" : [
{ "name" : " Python " , "show_code" : false },
{ "name" : " Python 2 " , "show_code" : false }
],
"languages_windows" : [
{ "name" : " Python 3.10 " , "extension" : " .py " , "command" : " py -3.10 " }
]
} Für jedes Objekt in einem Sprachen -Array ist der "name" -Staste erforderlich, und die Schlüssel "command" und "extension" sollten immer für neue benutzerdefinierte Sprachen bereitgestellt werden. Nicht jede Einstellung ist jedoch sinnvoll, um sich pro Sprachbasis anzuwenden. Zum Beispiel gilt "show_equal" für den Lauf der .many -Datei als Ganzes, so dass es im Basis -JSON -Objekt nur sinnvoll ist.
Alle beschriebenen Einstellungen und ob sie in den "languages" und "languages_<os>" -Array-Objekten pro Spruage auf einer Basis von "Sprachen" und "Languages_ <Os>" überschrieben werden können:
| JSON Key | Typ | Standard | Überschrieben | Beschreibung |
|---|---|---|---|---|
"command" | Saite | "echo NOCOMMAND" | Ja | Der Befehl console, um eine Sprache auszuführen, folgt dem Befehlsformat. |
"extension" | Saite | "" | Ja | Die Dateierweiterung einer Sprache, einschließlich des Punktes. |
"timeout" | schweben | 10.0 | Ja | Die Zeitlimit jedes Programms in Sekunden oder null für kürzester Zeit. |
"runs" | int | 1 | Ja | Die Häufigkeit, mit der jedes Programm ausgeführt wird. Es wird nur die Ausgabe des letzten Laufs angezeigt. |
"stderr" | Saite | "smart" | Ja | "yes" / true , um das Programm Stderr mit Stdout zu kombinieren. "no" / false , um Programm Stderr zu verbergen. "smart" / null , um nur STDERR zu zeigen, wenn Programme außerhalb Null-Exit-Codes vorliegen. |
"spacing" | int | 1 | Ja | Die Anzahl der leeren Zeilen, die nach jedem Lauf hinzugefügt werden sollen. |
"newline" | Saite | "n" | Ja | Welche Newlines werden in Code-, Argv- und Stdin -Snippet -Inhalten ersetzt. Oder null für das Betriebssystem. |
"tab" | Saite | "t" | Ja | Mit welchem TAB -Zeichen wird in Code-, Argv- und Stdin -Snippet -Inhalten ersetzt. |
"cwd" | Saite | null | Ja | Das aktuelle Arbeitsverzeichnis, um Programme auszuführen. Kann ein relativer Weg sein. Verwenden Sie null oder "." ohne Änderung des aktuellen Arbeitsverzeichnisses. |
"minimalist" | bool | false | NEIN | Ob alle Ausgaben in einem minimalen Format angezeigt werden sollen, bei dem die Trenner, Code, Argv und Stdin nicht angezeigt werden. |
"run_blanks" | bool | false | NEIN | Ob leere Ausschnitte, die nur aus Whitespace bestehen, werden ausgeführt oder ignoriert. |
"show_time" | bool | false | Ja | Ob die Ausführungszeit angezeigt wird. Nützlich für Leistungstests in Kombination mit "runs" . |
"show_command" | bool | false | Ja | Ob der Befehl zum Ausführen jedes Programms angezeigt wird. Nützlich zum Debuggen von Befehlen für neue Sprachen. |
"show_code" | bool | false | Ja | Ob der Quellcode des Programms angezeigt wird. |
"show_argv" | bool | true | Ja | Ob das Argv für das Programm angezeigt wird (wenn es vorhanden ist). |
"show_stdin" | bool | true | Ja | Ob das Stdin für das Programm angezeigt wird (wenn vorhanden). |
"show_output" | bool | true | Ja | Ob die Ausgabe für das Programm angezeigt wird. Dies schließt den Stdout und je nach "stderr" die Stderr ein. |
"show_runs" | bool | true | NEIN | Ob die Liste der Läufe angezeigt wird. Dies ist normalerweise der Großteil des Ausgangs. |
"show_stats" | bool | true | NEIN | Ob die Erfolgszahlen und Misserfolg gezeigt werden, nachdem alles gelaufen ist. |
"show_equal" | bool | true | NEIN | Ob die passenden Stdouts verglichen und gruppiert werden, nachdem alles gefahren ist. |
"show_errors" | bool | true | NEIN | Ob Runmany -Fehler wie ` |
"strip_argv" | Saite | "smart" | NEIN | "yes" / true , um den Snippet -Inhalt der führenden und nachverfolgenden Whitespace zu entfernen. "no" / false um den Snippet -Inhalt so zu halten, wie es ist. "smart" / null , um alle Zeilen im Snippet zusammen mit Räumen zu verbinden, als ob sie in einer Zeile wären. |
"strip_stdin" | Saite | "smart" | NEIN | "yes" / true , um den Start und Ende des Snippetes der nur Whitespace-Linien zu entfernen. "no" / false um den Snippet -Inhalt so zu halten, wie es ist. "smart" / null , um das Gleiche zu tun wie "yes" / true , aber auch eine einzelne neue Linie anhängen. |
"strip_code" | Saite | "smart" | Ja | "yes" / true , um den Start und Ende des Snippetes der nur Whitespace-Linien zu entfernen. "no" / false um den Snippet -Inhalt so zu halten, wie es ist. "smart" / null , um die Oberseite der .many -Datei als Beginn des Codes -Snippets mit allen irrelevanten Teilen zu behandeln, sodass Fehler in den Programmen korrekte Zeilennummern melden. |
"strip_output" | Saite | "no" | Ja | "yes" / true für Strip -Programmausgabe von führenden und nachfolgenden Whitespace. "no" / false , um die Programmausgabe so zu verlassen, wie es ist. "smart" / null , um Programmausgabe von leeren führenden und nachverfolgenden Linien zu streifen. |
Es sollte erwähnt werden, dass die Code-, Argv- und Stdin -Teile der .many -Dateiausgabe aus leeren Zeilen entzogen werden, um die Dinge unabhängig von den Werten von "strip_code" , "strip_argv" und "strip_stdin" visuell sauber zu halten.
Der "command" -Taste eines Objekts in den "languages" oder "languages_<os>" definiert den Terminalbefehl, der ausgeführt wird, um diese Sprache auszuführen.
Platzhalter wie $file und $dir können in einem Befehl verwendet werden, um auf den temporären Datei -Runmany zu verweisen, der für den Code jedes Programms erstellt wird, das er ausgeführt hat, und das Verzeichnis, das die Datei in:
| Platzhalter | Teil von .../dir/file.ext |
|---|---|
$rawdir | .../dir |
$dir | ".../dir" |
$rawfile | .../dir/file.ext |
$file | ".../dir/file.ext" |
$rawbranch | .../dir/file |
$branch | ".../dir/file" |
$name | file.ext |
$stem | file |
$ext | .ext |
$sep | / (Osspezifisch) |
$argv | N/A - Der Argv wird hier eingefügt |
$code | N/A - Der Rohausschnittinhalt |
Beachten Sie, dass einige Platzhalter "zitiert" werden und andere nicht. Einige Betriebssysteme wie Windows haben möglicherweise Leerzeichen im Pfad zu temporären Dateien, sodass korrektes Zitieren wichtig ist.
Wenn $ nirgendwo in der Befehlszeichenfolge vorhanden ist, wird $file $argv angehängt. Zum Beispiel ist der Befehl python implizit python $file $argv .
Weitere Beispiele für Befehle überprüfen Sie das Array "supplied_languages" in default_setings.json.
Ich war motiviert, Runmany durch meinen Wunsch zu machen, mehr Programmiersprachen zu lernen, kombiniert mit meinem Ärger, dass ich immer nach dem Versuch, ein ganz neues Projekt für diese Sprache zu machen oder sogar IDES zu wechseln.
Ich habe vor, es zu verwenden, um die Lösung von Code -Herausforderungen in mehreren Sprachen von Websites wie Project Euler zu üben.
Schauen Sie sich einige meiner anderen Python -Pakete an.
