Come posso eseguire un comando terminale (come grep) dalla mia applicazione Objective-C Cocoa?

È possibile utilizzare NSTask. Ecco un esempio che verrebbe eseguito ' /usr/bin/grep foo bar.txt'.

int pid = [[NSProcessInfo processInfo] processIdentifier];
NSPipe *pipe = [NSPipe pipe];
NSFileHandle *file = pipe.fileHandleForReading;

NSTask *task = [[NSTask alloc] init];
task.launchPath = @"/usr/bin/grep";
task.arguments = @[@"foo", @"bar.txt"];
task.standardOutput = pipe;

[task launch];

NSData *data = [file readDataToEndOfFile];
[file closeFile];

NSString *grepOutput = [[NSString alloc] initWithData: data encoding: NSUTF8StringEncoding];
NSLog (@"grep returned:\n%@", grepOutput);

NSPipee NSFileHandlevengono utilizzati per reindirizzare l'output standard dell'attività.

Per informazioni più dettagliate sull'interazione con il sistema operativo dall'applicazione Objective-C, è possibile consultare questo documento nel Centro di sviluppo di Apple: Interazione con il sistema operativo .

Modifica: correzione inclusa per il problema NSLog

Se si utilizza NSTask per eseguire un'utilità della riga di comando tramite bash, è necessario includere questa linea magica per far funzionare NSLog:

//The magic line that keeps your log where it belongs
task.standardOutput = pipe;

Una spiegazione è qui: https://web.archive.org/web/20141121094204/https://cocoadev.com/HowToPipeCommandsWithNSTask

L'articolo di Kent mi ha dato una nuova idea. questo metodo runCommand non ha bisogno di un file di script, esegue solo un comando da una riga:

- (NSString *)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];

    NSData *data = [file readDataToEndOfFile];

    NSString *output = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
    return output;
}

Puoi usare questo metodo in questo modo:

NSString *output = runCommand(@"ps -A | grep mysql");

nello spirito di condivisione ... questo è un metodo che uso frequentemente per eseguire script di shell. puoi aggiungere uno script al tuo pacchetto di prodotti (nella fase di copia della build) e quindi far leggere ed eseguire lo script in fase di esecuzione. nota: questo codice cerca lo script nel sotto-percorso privateFrameworks. attenzione: questo potrebbe essere un rischio per la sicurezza dei prodotti distribuiti, ma per il nostro sviluppo interno è un modo semplice per personalizzare cose semplici (come l'host da cui sincronizzare rsync a ...) senza ricompilare l'applicazione, ma semplicemente modificando il shell script nel 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);    
}
//------------------------------------------------------

Modifica: correzione inclusa per il problema NSLog

Se si utilizza NSTask per eseguire un'utilità della riga di comando tramite bash, è necessario includere questa linea magica per far funzionare NSLog:

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

Nel contesto:

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

Una spiegazione è qui: http://www.cocoadev.com/index.pl?NSTask

Ecco come farlo in Swift

Modifiche per Swift 3.0:

• NSPipe è stato rinominato Pipe

• NSTask è stato rinominato Process

Questo si basa sulla risposta Objective-C di inkit sopra. Lo ha scritto come una categoria su NSString- Per Swift, diventa un'estensione di String.

estensione 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 ---"
        }
    }
}

Uso:

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

    o semplicemente:

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

Esempio:

@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()

}

Nota il Processrisultato come letto da Pipeè un NSStringoggetto. Potrebbe essere una stringa di errore e può anche essere una stringa vuota, ma dovrebbe sempre essere una stringa NSString.

Quindi, fintanto che non è zero, il risultato può essere lanciato come Swift Stringe restituito.

Se per qualche motivo non è NSStringpossibile inizializzare affatto dai dati del file, la funzione restituisce un messaggio di errore. La funzione avrebbe potuto essere scritta per restituire un facoltativo String?, ma sarebbe scomodo da usare e non servirebbe a uno scopo utile perché è così improbabile che ciò accada.

Objective-C (vedi sotto per Swift)

Ripulito il codice nella risposta in alto per renderlo più leggibile, meno ridondante, aggiunto i vantaggi del metodo a una riga e trasformato in una categoria NSString

@interface NSString (ShellExecution)
- (NSString*)runAsCommand;
@end

Implementazione:

@implementation NSString (ShellExecution)

- (NSString*)runAsCommand {
    NSPipe* pipe = [NSPipe pipe];

    NSTask* task = [[NSTask alloc] init];
    [task setLaunchPath: @"/bin/sh"];
    [task setArguments:@[@"-c", [NSString stringWithFormat:@"%@", self]]];
    [task setStandardOutput:pipe];

    NSFileHandle* file = [pipe fileHandleForReading];
    [task launch];

    return [[NSString alloc] initWithData:[file readDataToEndOfFile] encoding:NSUTF8StringEncoding];
}

@end

Uso:

NSString* output = [@"echo hello" runAsCommand];

E se riscontri problemi con la codifica di output:

// Had problems with `lsof` output and Japanese-named files, this fixed it
NSString* output = [@"export LANG=en_US.UTF-8;echo hello" runAsCommand];

Spero ti sia utile come lo sarà per me futuro. (Ciao a te!)

Swift 4

Ecco un rapido esempio facendo uso di Pipe, ProcesseString

extension String {
    func run() -> String? {
        let pipe = Pipe()
        let process = Process()
        process.launchPath = "/bin/sh"
        process.arguments = ["-c", self]
        process.standardOutput = pipe

        let fileHandle = pipe.fileHandleForReading
        process.launch()

        return String(data: fileHandle.readDataToEndOfFile(), encoding: .utf8)
    }
}

Uso:

let output = "echo hello".run()

fork , exec e wait dovrebbero funzionare, se non stai davvero cercando un modo specifico per Objective-C. forkcrea una copia del programma attualmente in esecuzione, execsostituisce il programma attualmente in esecuzione con uno nuovo e waitattende la chiusura del sottoprocesso. Ad esempio (senza alcun controllo degli errori):

#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. */

C'è anche sistema , che esegue il comando come se fosse stato digitato dalla riga di comando della shell. È più semplice, ma hai meno controllo sulla situazione.

Suppongo che tu stia lavorando su un'applicazione Mac, quindi i collegamenti sono alla documentazione di Apple per queste funzioni, ma sono tutti POSIX, quindi dovresti usarli su qualsiasi sistema compatibile con POSIX.

Esiste anche un buon vecchio sistema POSIX ("echo -en '\ 007'");

Ho scritto questa funzione "C", perché NSTaskè odiosa ..

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 ..
…

oh, e per essere completo / non ambiguo ...

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

Anni dopo, Cè ancora un disastro sconcertante, per me .. e con poca fiducia nella mia capacità di correggere le mie gravi lacune sopra - l'unico ramo d'ulivo che offro è una versione rezhuzhed della risposta di @inket che è la più piccola delle ossa , per il mio collega puristi / detestatori della verbosità ...

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]; });
}

Custode Mortem disse:

Sono sorpreso che nessuno abbia avuto problemi di blocco / non blocco delle chiamate

Per problemi di chiamata bloccanti / non bloccanti riguardanti la NSTasklettura seguente:

asynctask.m - codice di esempio che mostra come implementare flussi stdin, stdout e stderr asincroni per l'elaborazione dei dati con NSTask

Il codice sorgente di asynctask.m è disponibile su GitHub .

Oltre alle numerose eccellenti risposte sopra, uso il seguente codice per elaborare l'output del comando in background ed evitare il meccanismo di blocco di [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];
}

O poiché l'Obiettivo C è solo C con sopra un livello di OO puoi usare le parti posteriori di posix:

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[]); 

Sono inclusi nel file di intestazione unistd.h.

Se il comando Terminale richiede il privilegio di amministratore (aka sudo), utilizzare AuthorizationExecuteWithPrivilegesinvece. Di seguito verrà creato un file denominato "com.stackoverflow.test" è la directory principale "/ Sistema / Libreria / Cache".

AuthorizationRef authorizationRef;
FILE *pipe = NULL;
OSStatus err = AuthorizationCreate(nil,
                                   kAuthorizationEmptyEnvironment,
                                   kAuthorizationFlagDefaults,
                                   &authorizationRef);

char *command= "/usr/bin/touch";
char *args[] = {"/System/Library/Caches/com.stackoverflow.test", nil};

err = AuthorizationExecuteWithPrivileges(authorizationRef,
                                         command,
                                         kAuthorizationFlagDefaults,
                                         args,
                                         &pipe);