orientée objet shell pour linux?

Python. Pas de blague.

Les langages de script sont les langages de script, Python et est particulièrement agréable que beaucoup de gens trouvent très accessible.

Perl, Python et Ruby

---

Ok, je suis sûr que vous le savez déjà, mais il fallait quelqu'un pour le dire.

Perl est le plus ancien et le plus populaire.

Si vous aimez les objets, vous aurez certainement l'amour de Rubis. Il a un complexe d'objet système inspiré de Smalltalk.

Python a ce cool structure en bloc par retrait de la syntaxe.

Unix est une mine d'or de pointe des outils de script...

NodeJS peut le faire, en fait, c'est l'un des échantillons inclus dans le téléchargement. L'utiliser de manière interactive, ou (probablement plus utile) écrire des scripts shell en JavaScript.

Par exemple:

#!/usr/local/bin/node

var sys  = require('sys'),
    exec = require('child_process').exec;

//Run `ls`:
exec('ls -lh /usr', function(error, output, erroutput) {
    sys.print('output:    ' + output);
    sys.print('erroutput: ' + erroutput);
});

...mais c'est juste l'interface de haut niveau que les tampons de toutes les données de sortie pour vous, etc. Vous pouvez obtenir beaucoup plus vers le bas et sale que cela, si vous le souhaitez.

NodeJS prend l'asynchronicité comme l'état normal de ses affaires, et donc, si vous voulez un "traditionnel" shell script, vous pouvez trouver ce n'est pas un bon match car il n'a pas (à ce jour, autant que je sache) offre une version synchrone de exec. De manière ad hoc de la série de série de déclarations devient un exercice rappels:

exec('first_command', function(error) {
    if (error != null) {
        exec('second_command', function(error) {
            if (error != null) {
                //....
            }
        });
    }
});

...mais bien sûr, vous pouvez créer une fonction qui gère pour vous et prend (dire) un tableau séquentiel des instructions à exécuter (et de l'installer comme un module via le Nœud du module sysstem). Ainsi, par exemple:

#!/usr/local/bin/node
var sys  = require('sys'),
exec = require('child_process').exec;
execSeries([
'ls -ld /usr',
'foobar',
'ls -ld /etc'
], {echo: true}, function(results) {
sys.print("Done\n");
});
//===> This would be in a module, not in the script itself <===
function execSeries(series, options, callback) {
var index = 0,
results = [];
//Make 'options' optional
if (!callback && typeof options === "function") {
callback = options;
options = undefined;
}
//Default options
options = options || {};
//Go
callNext();
function callNext() {
if (index >= series.length) {
//Done
callback(results);
}
else {
//Call the next one
exec(series[index++], function(error, stdout, stderr) {
//Record result
results.push({error: error, stdout: stdout, stderr: stderr});
//Echo?
if (options.echo) {
if (error == null) {
sys.print(stdout);
}
else {
sys.print("Error: " + error + "\n");
}
}
//Stop on error?
if (options.breakOnError && error != null) {
//Yes, and there was an error; stop
callback(results);
}
else {
//No, continue
callNext();
}
});
}
}
}

jq n'est pas tout à fait un shell orienté objet, mais il offre certains des avantages de l'orienté objet coquilles peuvent avoir; je l'utilise beaucoup, en collaboration avec les scripts shell, pour de telles tâches.