Exécuter une commande de terminal à partir d'un Cacao app

dans l'esprit de partage... c'est une méthode que j'utilise fréquemment pour exécuter des scripts shell.
vous pouvez ajouter un script à votre lot de produits (dans la phase de copie de la construction) et puis
le script de lire et d'exécuter au moment de l'exécution. remarque: ce code est pour le script dans le privateFrameworks sous-chemin.
avertissement: ce pourrait être un risque de sécurité pour les produits déployés, mais pour notre propre développement, c'est un moyen facile de personnaliser les choses simples (comme l'hôte de rsync pour...) sans re-compilation de l'application, mais juste éditer le script shell dans le bundle.

//------------------------------------------------------
-(void) runScript:(NSString*)scriptName
{
    NSTask *task;
    task = [[NSTask alloc] init];
    [task setLaunchPath: @"/bin/sh"];

    NSArray *arguments;
    NSString* newpath = [NSString stringWithFormat:@"%@/%@",[[NSBundle mainBundle] privateFrameworksPath], scriptName];
    NSLog(@"shell script path: %@",newpath);
    arguments = [NSArray arrayWithObjects:newpath, nil];
    [task setArguments: arguments];

    NSPipe *pipe;
    pipe = [NSPipe pipe];
    [task setStandardOutput: pipe];

    NSFileHandle *file;
    file = [pipe fileHandleForReading];

    [task launch];

    NSData *data;
    data = [file readDataToEndOfFile];

    NSString *string;
    string = [[NSString alloc] initWithData: data encoding: NSUTF8StringEncoding];
    NSLog (@"script returned:\n%@", string);    
}
//------------------------------------------------------

Edit: Inclus correctif pour NSLog problème

Si vous utilisez NSTask pour exécuter un utilitaire de ligne de commande via bash, vous devez inclure cette ligne magique pour garder NSLog de travail:

//The magic line that keeps your log where it belongs
[task setStandardInput:[NSPipe pipe]];

En contexte:

NSPipe *pipe;
pipe = [NSPipe pipe];
[task setStandardOutput: pipe];
//The magic line that keeps your log where it belongs
[task setStandardInput:[NSPipe pipe]];

Une explication est ici: http://www.cocoadev.com/index.pl?NSTask

Voici comment le faire en Swift

Changements pour Swift 3.0:

• NSPipe a été renommé Pipe

• NSTask a été renommé Process

---

Ceci est basé sur inkit de l'Objective-C réponse ci-dessus. Il l'a écrit comme un catégorie sur NSString —
Pour Swift, il devient un extension de String.

extension  String.runAsCommand()  ->  String

extension String {
    func runAsCommand() -> String {
        let pipe = Pipe()
        let task = Process()
        task.launchPath = "/bin/sh"
        task.arguments = ["-c", String(format:"%@", self)]
        task.standardOutput = pipe
        let file = pipe.fileHandleForReading
        task.launch()
        if let result = NSString(data: file.readDataToEndOfFile(), encoding: String.Encoding.utf8.rawValue) {
            return result as String
        }
        else {
            return "--- Error running command - Unable to initialize string from file data ---"
        }
    }
}

---

Utilisation:

let input = "echo hello"
let output = input.runAsCommand()
print(output)                        //prints "hello"

    ou tout simplement:

print("echo hello".runAsCommand())   //prints "hello" 

Exemple:

@IBAction func toggleFinderShowAllFiles(_ sender: AnyObject) {

    var newSetting = ""
    let readDefaultsCommand = "defaults read com.apple.finder AppleShowAllFiles"

    let oldSetting = readDefaultsCommand.runAsCommand()

    //Note: the Command results are terminated with a newline character

    if (oldSetting == "0\n") { newSetting = "1" }
    else { newSetting = "0" }

    let writeDefaultsCommand = "defaults write com.apple.finder AppleShowAllFiles \(newSetting) ; killall Finder"

    _ = writeDefaultsCommand.runAsCommand()

}

---

Note le Process résultat que de les lire à partir de la Pipe est un NSString objet. Il pourrait être une erreur de chaîne et il peut aussi être une chaîne vide, mais il devrait toujours être un NSString.

Donc, tant qu'il n'est pas nul, le résultat peut lancer comme rapide String et retourné.

Si pour une raison quelconque ne NSString peut être initialisé à partir du fichier de données, la fonction renvoie un message d'erreur. La fonction pourrait avoir été écrit pour revenir une option String?, mais ce serait difficile à utiliser et ne pas servir à des fins utiles, parce que c'est tellement improbable que cela se produise.

fourche, exec, et attendre devrait fonctionner, si vous n'êtes pas vraiment à la recherche d'un Objectif-C de manière spécifique. fork crée une copie du programme en cours d'exécution, exec remplace le programme en cours d'exécution avec un nouveau, et wait attend pour le sous-processus de sortie. Par exemple (sans contrôle d'erreur):

#include <stdlib.h>
#include <unistd.h>

pid_t p = fork();
if (p == 0) {
    /* fork returns 0 in the child process. */
    execl("/other/program/to/run", "/other/program/to/run", "foo", NULL);
} else {
    /* fork returns the child's PID in the parent. */
    int status;
    wait(&status);
    /* The child has exited, and status contains the way it exited. */
}

/* The child has run and exited by the time execution gets to here. */

Il y a aussi système, qui exécute la commande que si vous avez tapé à partir de la ligne de commande du shell. C'est plus simple, mais vous avez moins de contrôle sur la situation.

Je suis en supposant que vous travaillez sur une application Mac, de sorte que les liens sont à la documentation d'Apple pour ces fonctions, mais ils sont tous POSIX, de sorte que vous devriez être à utiliser sur n'importe quel conforme à POSIX système.

J'ai écrit cette fonction "C", parce que NSTask est désagréable..

NSString * runCommand(NSString* c) {

    NSString* outP; FILE *read_fp;  char buffer[BUFSIZ + 1];
    int chars_read; memset(buffer, '
NSString * runCommand(NSString* c) {
NSString* outP; FILE *read_fp;  char buffer[BUFSIZ + 1];
int chars_read; memset(buffer, '\0', sizeof(buffer));
read_fp = popen(c.UTF8String, "r");
if (read_fp != NULL) {
chars_read = fread(buffer, sizeof(char), BUFSIZ, read_fp);
if (chars_read > 0) outP = $UTF8(buffer);
pclose(read_fp);
}   
return outP;
}
NSLog(@"%@", runCommand(@"ls -la /")); 
total 16751
drwxrwxr-x+ 60 root        wheel     2108 May 24 15:19 .
drwxrwxr-x+ 60 root        wheel     2108 May 24 15:19 ..
…
', sizeof(buffer));
    read_fp = popen(c.UTF8String, "r");
    if (read_fp != NULL) {
        chars_read = fread(buffer, sizeof(char), BUFSIZ, read_fp);
        if (chars_read > 0) outP = $UTF8(buffer);
        pclose(read_fp);
    }   
    return outP;
}

NSLog(@"%@", runCommand(@"ls -la /")); 

total 16751
drwxrwxr-x+ 60 root        wheel     2108 May 24 15:19 .
drwxrwxr-x+ 60 root        wheel     2108 May 24 15:19 ..
…

oh, et par souci d'être complet /sans ambiguïté...

#define $UTF8(A) ((NSString*)[NSS stringWithUTF8String:A])

Ans plus tard, C est toujours un incroyable gâchis, pour moi.. et avec un peu de foi en ma capacité à corriger mon brut lacunes au - dessus de la seule branche d'olivier que je propose est un rezhuzhed version de @inket de la réponse qui est plus strict des os, pour mes collègues puristes /verbosité-haters...

id _system(id cmd) { 
   return !cmd ? nil : ({ NSPipe* pipe; NSTask * task;
  [task = NSTask.new setValuesForKeysWithDictionary: 
    @{ @"launchPath" : @"/bin/sh", 
        @"arguments" : @[@"-c", cmd],
   @"standardOutput" : pipe = NSPipe.pipe}]; [task launch];
  [NSString.alloc initWithData:
     pipe.fileHandleForReading.readDataToEndOfFile
                      encoding:NSUTF8StringEncoding]; });
}

Ou étant donné que l'Objectif C est juste C avec quelques OO couche sur le dessus, vous pouvez utiliser la posix conterparts:

int execl(const char *path, const char *arg0, ..., const char *argn, (char *)0);
int execle(const char *path, const char *arg0, ..., const char *argn, (char *)0, char *const envp[]);
int execlp(const char *file, const char *arg0, ..., const char *argn, (char *)0);
int execlpe(const char *file, const char *arg0, ..., const char *argn, (char *)0, char *const envp[]);
int execv(const char *path, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[], char *const envp[]); 

Ils sont inclus à partir de unistd.h fichier d'en-tête.

Outre plusieurs excellentes réponses ci-dessus, j'utilise le code suivant pour traiter la sortie de la commande en arrière-plan et d'éviter le mécanisme de blocage de [file readDataToEndOfFile].

- (void)runCommand:(NSString *)commandToRun
{
    NSTask *task = [[NSTask alloc] init];
    [task setLaunchPath:@"/bin/sh"];

    NSArray *arguments = [NSArray arrayWithObjects:
                          @"-c" ,
                          [NSString stringWithFormat:@"%@", commandToRun],
                          nil];
    NSLog(@"run command:%@", commandToRun);
    [task setArguments:arguments];

    NSPipe *pipe = [NSPipe pipe];
    [task setStandardOutput:pipe];

    NSFileHandle *file = [pipe fileHandleForReading];

    [task launch];

    [self performSelectorInBackground:@selector(collectTaskOutput:) withObject:file];
}

- (void)collectTaskOutput:(NSFileHandle *)file
{
    NSData      *data;
    do
    {
        data = [file availableData];
        NSLog(@"%@", [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding] );

    } while ([data length] > 0); //[file availableData] Returns empty data when the pipe was closed

    //Task has stopped
    [file closeFile];
}