Apple a créé un nouveau langage pour compléter Objectif c: Rapide. Rapide est toujours dans la classe de langage C, mais a quelques caractéristiques d'un langage interprété. La syntaxe plus simple comparée à Objectif c rendra l'apprentissage et l'utilisation beaucoup plus facile. Rapide est utilisable comme interprète ou compilateur.
Je présente ce langage en montrant comment l’utiliser avec Alfred Workflows et je suppose que vous connaissez déjà l’écriture de workflows dans Alfred. Si non, s'il vous plaît consulter ces tutoriels: Alfred pour Débutants, Intermédiaires, Avancée, et Alfred Debugging.
Ce tutoriel se concentre sur l’utilisation de Rapide avec Alfred et non une référence linguistique complète. Il y a une excellente série de tutoriels sur l'apprentissage Rapide sur les Tuts de Code+, Une introduction à Swift: Partie 1 et Une introduction à Swift: Partie 2. Je supposerai que vous avez déjà lu ces articles.
À installer Rapide sur un Mac, vous devez installer XCode à partir de l'App Store. Une fois installé, vous devez ouvrir une fenêtre de terminal et lancer:
xcode-select -s /Applications/Xcode.app/ --install
Cela rendra tous les outils XCode disponibles à la ligne de commande.
Vous pouvez compiler et expérimenter avec Rapide dans XCode 6.1 et son Cour de récréation. Ce tutoriel se concentre sur l’utilisation de Rapide sur la ligne de commande en utilisant uniquement l'éditeur du programmeur et la ligne de commande.
En supposant que vous avez installé XCode 6.1 au Applications dossier, vous devrez ajouter Rapidele répertoire des exécutables du chemin. Pour Frapper, ajoutez ceci à votre ~ / .bashrc fichier:
export PATH = "$ PATH: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin"
Pour Zsh, ajouter la même ligne à votre ~ / .zshrc fichier. Pour Poisson shell, ajoutez cette ligne:
set -xg PATH "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin" $ PATH
J'ai trouvé qu'en utilisant le xcrun commande sans avoir le PATH défini comme ci-dessus ne fonctionne pas toujours.
Compiler Rapide fichiers sur la ligne de commande, vous tapez:
rapide
Courir Rapide dans un interprète interactif, vous tapez:
rapide
Ajouter Rapide soutien Texte sublime est facile. Installez le Gestionnaire de packages pour Sublime Text. Une fois que vous avez le gestionnaire de paquets, vous devez installer le paquet Rapide en utilisant Maj-Commande-P, type installation du paquet, entrer, et Rapide. Cela devrait installer le Rapide paquet.
Sur Emacs, le gestionnaire de paquets pour Emacs est le meilleur itinéraire, mais c’est seulement Emacs 24+. Pour Emacs 24+, vous devez télécharger et installer Aquamacs. le Emacs installé sur un Mac standard correspond à la version 22. Pour installer Aquamacs en utilisant HomeBrew et HomeBrew Cask, tapez ceci dans un terminal:
tonneau de bière installer aquamac
Une fois installé, vous devez ajouter ceci à votre ~ / .emacs fichier:
Accentsconagua
Share(nécessite 'package) (package-initialize) (add-to-list' package-archives '("melpa". "http://melpa.milkbox.net/packages/")) Courir Aquamacs et ouvrez le Gestionnaire de paquets Emacs avec Meta-x package-list-packages.
Gestionnaire de paquets Emacs Chercher mode rapide et cliquez dessus. Vous devrez peut-être installer flycheck ainsi que.
Pour Vim, vous devez installer Swift.Vim. Le moyen le plus simple d'installer Swift.Vim est d'installer maximum-génial premier. À installer maximum-génial, ouvrir un terminal dans le ~ / Documents (ou tout autre répertoire. Ce doit être un endroit où vous avez l'intention de garder.). Tapez ce qui suit:
git clone https://github.com/square/maximum-awesome.git cd maximum-génial rake
L'installation prendra un certain temps. Ensuite, ajoutez cette ligne à votre ~ / .vimrc.bundle.local fichier:
Plugin 'Keithbsmiley / swift.vim'
Une fois enregistré, réexécutez Vim et le type
: PluginInsall
Vundle, lequel maximum-génial installe, installera tous les nouveaux plugins.
Vundler Installation de Swift.Vim Dans ce cas, Vundler installe le Swift.Vim brancher. Vim va maintenant faire la coloration syntaxique pour Rapide.
Rapide peut fonctionner en tant qu'interprète ou compilateur. Pour illustrer cela, créez un fichier bonjour et ajoutez ceci:
#! / usr / bin / env xcrun -sdk macosx swift println ("Hello World!") C'est le plus fondamental Bonjour le monde programme que les gens utilisent comme leur premier programme. La première ligne indique au shell que vous voulez exécuter ce script en utilisant xcrun avec la ligne de commande spécifiée. xcrun est un programme Mac OSX pour exécuter les utilitaires XCode à partir de la ligne de commande.
Enregistrez le fichier et changez son mode d'exécution avec
chmod x + a hello.swift
Exécuter le fichier avec
./hello.swift
Et cela produira Bonjour le monde! sur le terminal en exécutant le script avec Rapide en tant qu'interprète. Pour compiler, tapez ceci sur le terminal:
swiftc hello.swift
UNE Bonjour programme existe maintenant dans ce répertoire. Type
./Bonjour
et vous verrez exactement la même sortie.
Programme Hello World Les deux méthodes ont produit exactement le même résultat. La seule chose différente est que pour l'approche interprétée, XCode 6 doit être sur chaque système qui l'exécute. Si vous compilez le programme, il peut être exécuté sur n’importe quel Mac.
Il est intéressant de noter que l’approche interprétée est identique à l’approche compilée pour ce qui est exécuté. En mode interprété, il compile le programme en mémoire et s’exécute directement en mémoire. L'approche compilée est compilée sur disque et vous exécutez le programme. Globalement, vous ne gagnez pas de temps en interprétant le code Swift.
Faire des programmes d’écriture pour une utilisation dans Alfred, une bibliothèque de fonctions d'assistance peut être un grand atout. Créez un nouveau fichier appelé Alfred.swift et placez ce code à l'intérieur:
// // Classe: Alfred // // Description: Cette classe aide à créer des flux de travail pour Alfred en // utilisant le langage Swift d'Apple. // // Variables de classe: // // Nom Description // // chemin du cache vers le répertoire qui contient le cache du flux de travail // chemin de données vers le répertoire contenant les données du flux de travail // bundleId L'ID du ensemble qui représente le flux de travail // chemin d'accès au répertoire du flux de travail // chemin d'accès au répertoire de base de l'utilisateur // résulte en résultats cumulés. Cela sera converti en liste XML // pour les commentaires en Alfred // // // Importer les bibliothèques nécessaires. // import Foundation // // Définit les structures utilisées. // struct AlfredResult var UID: String = "" var Arg: String = "" var Titre: String = "" var Sub: String = "" var Icône: String = "" var Valide: String = "" var Auto: String = "" var Rtype: String = "" // // Classe: Regex // // Description: Il s'agit d'une classe auxiliaire permettant d'écrire des tests à l'aide d'expressions régulières. Basé sur // l'article: http://benscheirman.com/2014/06/regex-in-swift/ // classe Regex let internalExpression: NSRegularExpression let modèle: String init (_ modèle: String) self.pattern = modèle Erreur var: NSError? self.internalExpression = NSRegularExpression (modèle: modèle, options: .CaseInsensitive, erreur: et erreur)! func test (input: String) -> Bool let matches = self.internalExpression.matchesInString (entrée, options: nil, étendue: NSMakeRange (0, count (entrée))) renvoie matches.count> 0 // / / Class: Alfred // // Description: cette classe comprend les fonctions nécessaires à l'écriture de flux de travail pour Alfred. // Classe publique Alfred var cache: String = "" var data: String = "" var bundleId: String = "" chemin var: String = "" var home: String = "" var fileMGR: NSFileManager = NSFileManager () var maxResults: Int = 10 var currentResult: Int = 0 var résultats: [AlfredResult] = [] // // Classe de bibliothèque Fonction: // // init Cette fonction de classe est appelée lors de l'utilisation de la bibliothèque pour initialiser // toutes les variables utilisées pour la bibliothèque avant que quiconque // puisse faire appel à une fonction de classe de bibliothèque. // public init () // // Crée le tableau de résultats. // var resfirst: AlfredResult = AlfredResult () resfirst.Title = "Aucune correspondance trouvée ..." resfirst.Uid = "default" resfirst.Valid = "no" resfirst.Arg = "" resfirst.Sub = "" resfirst.Icon = "" resfirst.Auto = "" resfirst.Rtype = "" results.append (resfirst) maxResults = 10 currentResult = 0 // // Définit les variables de chemin d'accès et de base à partir de l'environnement. // dans l'objectif C: NSString * path = [[[[NSProcessInfo processInfo]] environment] objectForKey: @ "PATH"]; // let process = NSProcessInfo.processInfo (); let edict = NSDictionary (dictionary: process.environment) path = fileMGR.currentDirectoryPath home = edict ["HOME"] en tant que! String // // Si le fichier info.plist existe, lisez-le pour le bundleid et définissez la variable bundleId. // bundleId = GetBundleId () // // Crée la structure de répertoires pour les répertoires de cache et de données. // cache = home + "/Library/Caches/com.runningwithcrayons.Alfred-2/Workflow Data /" + bundleId; data = home + "/ Bibliothèque / Application Support / Alfred 2 / Données de flux de travail /" + bundleId; // // Voir si le répertoire de cache existe. // if (! fileMGR.fileExistsAtPath (cache)) // // Il n'existe pas. Créez le! // fileMGR.createDirectoryAtPath (cache, avecIntermediateDirectories: true, attributs: nil, erreur: nil) // // Vérifie si le répertoire de données existe. // if (! fileMGR.fileExistsAtPath (data)) // // Il n'existe pas. Créez le! // fileMGR.createDirectoryAtPath (data, withIntermediateDirectories: true, attributs: nil, error: nil) // // fonction de classe: GetBundleId // // Description: Cette fonction de classe lira les flux de travail info.plist et renverra // le bundleid // public func GetBundleId () -> String // // récupère l'ID du bundle à partir de la liste de sélection, s'il n'a pas déjà été récupéré. // if (bundleId == "") let path = NSBundle.mainBundle (). pathForResource ("info", ofType: "plist") let dict = NSDictionary (contentsOfFile: path!)! bundleId = dict ["bundleid"] en tant que! String // // Renvoie l'ID de l'ensemble. // return (bundleId) // // class Fonction: Cache // // Description: Cette fonction renvoie le répertoire de cache du flux de travail. // public func Cache () -> Chaîne return (cache) // // class Fonction: Données // // Description: Cette fonction renvoie le répertoire de données du flux de travail. // public func Data () -> Chaîne return (data) // // class Fonction: Path // // Description: Cette fonction renvoie le chemin d'accès au workflow. // fonction publique chemin Path () -> String return (path) // // class Fonction: Home // // Description: Cette fonction renvoie le répertoire Home de l'utilisateur. // fonction publique Home () -> Chaîne return (home) // // classe Fonction: ToXML // // Description: cette fonction de classe prend le tableau de résultats et en fait une // Chaîne XML à utiliser pour Alfred // fonction publique ToXML () -> String var newxml: String = ""for result in résultats newxml + ="\ (result.Arg) \ (result.Title) \ (result.Sub)\ (result.Icon) "return (newxml) // // fonction de classe: AddResult // // Description: fonction de classe auxiliaire facilitant le passage de valeurs // dans une fonction de classe // et la création d'un résultat de tableau à renvoyer à Alfred . // // Entrées: // uid le uid du résultat, doit être unique // argumenter l'argument qui sera transmis // titre Le titre de l'élément de résultat // sub Le texte du sous-titre pour l'élément de résultat // icon l'icône à utiliser pour l'élément de résultat // valide détermine si l'élément de résultat peut être activé // auto la valeur de saisie semi-automatique de l'élément de résultat // type je n'ai aucune idée de ce à quoi celui-ci est utilisé. HELP! // public func AddResult (uid: String, argument: String, titre: String, sous: String, icône: String, valide: String, auto: String, type de chaîne: String) // // Ajoute le nouveau tableau de résultats s'il n'est pas complet. / / if (currentResult < maxResults) if(currentResult != 0) var resfirst:AlfredResult = AlfredResult() resfirst.Title = title resfirst.Uid = uid resfirst.Valid = valid resfirst.Arg = arg resfirst.Sub = sub resfirst.Icon = icon resfirst.Auto = auto resfirst.Rtype = rtype results.append(resfirst) else results[0].Title = title results[0].Uid = uid results[0].Valid = valid results[0].Arg = arg results[0].Sub = sub results[0].Icon = icon results[0].Auto = auto results[0].Rtype = rtype currentResult++ // // class Function: AddResultsSimilar // // Description: This class function will only add the results that are similar to the // input given. This is used to select input selectively from what the // user types in. // // Inputs: // inString the String to test against the titles to allow that record or not // uid the uid of the result, should be unique // arg the argument that will be passed on // title The title of the result item // sub The subtitle text for the result item // icon the icon to use for the result item // valid sets whether the result item can be actioned // auto the autocomplete value for the result item // rtype I have no idea what this one is used for. HELP! // public func AddResultsSimilar(uid: String, inString: String, arg: String, title: String, sub: String, icon: String, valid: String, auto: String, rtype: String) // // Create the test pattern. // var matchstr = inString + ".*" // // Compare the match String to the title for the Alfred output. // if(Regex(inString + ".*").test(title)) // // A match, add it to the results. // AddResult( uid, arg: arg, title: title, sub: sub, icon: icon, valid: valid, auto: auto, rtype: rtype) // // class Function: SetDefaultString // // Description: This class function sets a different default title // // Inputs: // title the title to use // public func SetDefaultString(title: String) if(currentResult == 0) // // Add only if no results have been added. // results[0].Title = title C’est un port de ma bibliothèque de langues Alfred go que j’utilise dans le tutoriel Suivre le temps du projet avec Alfred Timekeeper pour Rapide. Je définis une structure, AlfredResult, garder les objets à retourner à un Filtre de script dans Alfred, une classe pour utiliser le NSRegularExpression Objectif c classe et Alfred classe pour gérer tout ce qui un Alfred flux de travail aurait besoin.
A ce stade, vous avez remarqué que j'ai mentionné un Objectif c classe. Rapide ne supprime pas la nécessité d'utiliser Objectif c bibliothèques. le Rapide bibliothèque standard a des constructions de langage de base et des routines. Rien qui soit spécifique au système d'exploitation. Tout Objectif c les bibliothèques sont utilisables directement à partir de Rapide. Alors, ne jetez pas tous vos Objectif c manuels de référence. Ils sont toujours nécessaires.
le Alfred class a une routine d'initialisation qui obtient les différents chemins de répertoire qu'un flux de travail doit utiliser et crée les répertoires de données et de cache s'ils n'existent pas déjà. Les méthodes AddResult () et AddResultsSimilar () créer la structure de résultats pour les sorties XML à Alfred. le AddResultsSimilar () ajoute le résultat uniquement s'il était similaire à la ligne de titre. le ToXML () la fonction génère le XML du tableau de résultats.
L'exemple de flux de travail sera un convertisseur de cas. Je l'ai créé une fois en PHP, mais pour de nombreux systèmes, il fonctionne très lentement. Il faudra une ficelle sur le Alfred ou à partir de la sélection OSX en utilisant un raccourci clavier, et donnez une liste des conversions disponibles. Il montre la conversion obtenue au fur et à mesure que vous tapez. La conversion sélectionnée par l'utilisateur est celle envoyée au presse-papiers et à l'application principale..
Flux de travail Alfred Case Converter Créez un flux de travail Alfred comme vous le voyez ci-dessus.
Filtre de script du flux de travail Met le ScriptFilter comme vous voyez ci-dessus. Sélectionnez le Ouvrir le dossier de workflow dans le coin en bas à droite. UNE Chercheur La fenêtre s’ouvre sur le répertoire du workflow. Copier le Bibliothèque Alfred fichier créé précédemment dans ce répertoire. Puis créez un nouveau fichier appelé tcconverter.swift et ajoutez ce code au bas du fichier:
// // Programme: Convertisseur de cas de texte (tcconverter) // // Description: ce programme utilisera une chaîne sur la ligne de commande, le convertira // de plusieurs manières et créera une sortie XML pour afficher // dans un script Alfred. Filtre. // // // Bibliothèques d'importation: // import Alfred import Convertisseur de classe Foundation init () // // Crée l'objet Alfred. // var wf = Alfred () // // Récupère la chaîne de ligne de commande et initialise le décompte. // let str: String = Process.arguments [1] var count = 0 // // Vers une chaîne en majuscule. // var result = str.capitalizedString wf.AddResult ("CS \ (nombre)", argument: résultat, titre: "Majuscule: \ (résultat)", sous: "Convertisseur de casse du texte", icône: "icon.png" , valide: "oui", auto: "", type: "") count ++ // // Crée une chaîne en minuscule. // resultat = str.lowercaseString wf.AddResult ("CS \ (nombre)", argument: result, titre: "Minuscules: \ (result)", sous: "Convertisseur de casse du texte", icon: "icon.png", valid: "yes", auto: "", rtype: "") count ++ // // Crée une chaîne en majuscule. // resultat = str.uppercaseString wf.AddResult ("CS \ (nombre)", argument: result, titre: "Majuscule: \ (result)", sous: "Convertisseur de casse du texte", icon: "icon.png", valid: "yes", auto: "", rtype: "") count ++ // // Crée une chaîne Titlecase. // resultat = TitleCase (str) wf.AddResult ("CS \ (compte)", argument: result, titre: "Titre: \ (result)", sous: "Convertisseur de cas de texte", icon: "icon.png" , valide: "oui", auto: "", type: "") count ++ // // Affiche le XML. // println (wf.ToXML ()) // // Méthode: TitleCase // // Description: Cette méthode convertit la chaîne donnée en cas de titre. // // Entrée: // str La chaîne à convertir. // funC TitleCase (str: String) -> String // // Crée un tableau de mots pour faire des minuscules. // let lower = ["to", "an", "et", "at", "comme", "mais", "par", "pour", "si", "dans", "sur", "ou", "est", "avec", "a", "le", "de", "vs", "vs.", "via", "via", "en"] // // Créer un tableau de mots qui doivent être en majuscule. // let upper = ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "HTML", "CSS", "AT & T", "PHP"] // // Fractionner la chaîne par des espaces. // mots var = str.componentsSeparatedByString ("") // // initialise les variables auxiliaires. // var result = "" var first = true // // Boucle chaque mot. // for word in words // // Crée une minuscule du mot et le mot obtenu en majuscule. // var lword = word.lowercaseString var res = word.capitalizedString // // Boucle en boucle chaque mot devant être en minuscule. // pour bas en bas si lword == low.lowercaseString // // Ce doit être en minuscule. Définissez le mot de résultat sur celui-ci et sortez de la boucle. // res = low break // // Boucle en boucle chaque mot devant être mis en majuscule. // for up in upper if lword == up.lowercaseString // // Il devrait être en majuscule. Définissez le mot de résultat et sortez. // res = up break // // S'il s'agit du premier mot, il faut toujours mettre en majuscule. // si premier res = res.capitalizedString first = false // // Crée la chaîne résultante. // résultat + = "\ (res)" // // Renvoie le résultat. // return (result) let cv: Converter = Converter () Ce code définit le Convertisseur objet. Cet objet crée les différentes versions de la chaîne et les affecte à la liste de résultats XML. Une fois complètement construit, il envoie le XML à la sortie.
le Convertisseur objet a la TitleCase () méthode pour créer une version de casse de titre de la chaîne. Il compare chaque mot de la chaîne au tableau des minuscules et du tableau des majuscules. Si trouvé dans ceux-ci, il définit le mot à cette valeur. Il s'assure toujours que le premier mot est en majuscule.
Compiler une bibliothèque pour une application est un peu complexe. Dans le programme Terminal.app ou iTerm.app, exécutez ces lignes de commande dans le répertoire contenant les sources..
Une fois les quatre étapes exécutées, vous aurez le programme tcconverter dans ce répertoire. Si vous modifiez le code tcconverter.swift, il vous suffit de réexécuter la dernière commande. Si vous modifiez le code Alfred.swift, vous devrez réexécuter les quatre lignes..
Le programme convertisseur devrait maintenant être dans le répertoire de flux de travail. Vous pouvez le tester dans le Alfred rapide:
Tester le code Le fichier de téléchargement contient tous ces fichiers et le workflow à examiner..
Dans ce tutoriel, je vous ai montré comment installer Rapide sur le Mac, configurez trois éditeurs de programmes et shells différents, exécutez Rapide programmes dans un terminal, et utiliser Rapide construire Alfred flux de travail.
C'est beaucoup de connaissances que vous devez pratiquer pour vous souvenir. Par conséquent, allez faire de grands Alfred flux de travail dans Rapide et les partager avec tout le monde!
