Avec Powershell, il est en fait possible de créer un raccourci à partir de zéro, mais aussi d’en lire les propriétés et de les modifier, en utilisant simplement les fonctionnalités de l’objet COM Wscript.Shell.

Pour cela, il faut commencer par créer un nouvel objet Wscript.Shell en utilisant la cmdlet New-Object :

$Shell = New-Object -ComObject Wscript.Shell

Ensuite, on utilise la méthode CreateShortcut pour créer un objet raccourci associé à un chemin. Le nom de cette méthode est un peu trompeur car elle s’applique aussi bien que vous souhaitiez créer, lire ou modifier un raccourci. En fait, elle ne crée pas véritablement le raccourci sur le disque dur mais seulement sa représentation en mémoire (instanciation de la classe WshShortcut ou WshURLShortcut). Elle prend en paramètre le chemin du raccourci à lire ou à créer. Penser bien à ajouter l’extension .lnk ou .url selon que votre raccourci pointe respectivement vers un fichier ou une adresse Internet.

$Shortcut = $Shell.CreateShortcut($env:USERPROFILE + "\Desktop\Mon raccourci.lnk")

Vous disposez ensuite d’un ensemble de propriétés sur l’objet obtenu que vous pouvez lire ou modifier selon vos souhaits :

# Cible du raccourci
$Shortcut.TargetPath = "C:\chemin\vers\votre\executable.exe"
# Paramètres optionnels de ligne de commande
$Shortcut.Arguments = "-arguments –si -necessaire"
# Dossier cible
$Shortcut.WorkingDirectory = "C:\chemin\vers\le\dossier\de\travail";
# Taille de la fenêtre d'exécution (normale, réduite ou agrandie)
$Shortcut.WindowStyle = 1;
# Raccourci clavier
$Shortcut.Hotkey = "CTRL+SHIFT+F";
# Chemin vers l'icône du raccourci
$Shortcut.IconLocation = "C:\chemin\vers\votre\executable.exe, 0";

A noter que dans le cas d’un raccourci vers une adresse Internet, seule la propriété TargetPath est disponible.

Enfin, vous pouvez faire appel à la méthode Save pour enregistrer le raccourci créé ou les modifications apportées à un raccourci existant :

$Shortcut.Save()

Et c’est tout ! Plutôt simple n’est-ce pas ?

Pour aller un peu plus loin, on peut ensuite combiner tout cela pour créer une ou plusieurs fonctions de manipulation des fichiers raccourcis. Voici par exemple une fonction permettant de récupérer le chemin cible d'un raccourci :

function function Get-ShortcutTarget {
    <#
    .SYNOPSIS
        This function returns the target of a shortcut file (LNK or URL extension).
    .EXAMPLE
        Get-ShortcutTarget -FilePath 'C:\Users\profilename\Desktop\MyShortcut.lnk'
    .PARAMETER FilePath
        The shortcut's file path (don't forget the extension !)
    #>
    [CmdletBinding()]
    param (
        [Parameter(Mandatory = $true, Position = 0, ValueFromPipeline = $true)]
        [ValidateScript({ Test-Path -Path $_ -PathType Leaf })]
        [Alias('Fullname')]
        [string[]]$FilePath
    )
    process {
        $ShellObject = New-Object -ComObject Wscript.Shell
        ($ShellObject.CreateShortcut($FilePath)).TargetPath
    }
}

A vous ensuite d'adapter ou de créer vos propres fonctions selon vos besoins. N'hésitez pas également à faire quelques recherches sur Internet, et notamment sur Github, où vous pourrez trouver des fonctions toutes prêtes pour traiter les raccourcis, comme ici par exemple.

Pour améliorer les performances, ou plutôt ne pas les plomber, il existe deux techniques simples, appelées debounce et throttle. Toutes deux permettent de réduire le nombre d'appels à une fonction dans un intervalle de temps donné. En effet, il est souvent inutile d'exécuter ces fonctions à chaque fois que l’événement est déclenché.

Imaginons par exemple que l'on souhaite synchroniser sur le serveur, via des appels AJAX, le contenu d'un champ de saisie au fur et à mesure que l'utilisateur tape le texte (comme le fait Google Docs par exemple). Dans ce cas, plutôt que de solliciter le serveur à chaque caractère saisi ou inutilement lorsque le texte reste inchangé, il peut être plus judicieux de sauvegarder le texte toutes les 5 secondes tant que l'utilisateur le modifie, et de ne plus faire de requêtes lorsque que le texte reste inchangé. Et c'est exactement ce que la fonction throttle permet de faire.

Cependant, bien que ces deux techniques soit assez similaires, il existe une différence fondamentale dans leurs fonctionnements qu'il est important de bien comprendre pour les utiliser correctement.

Je vais donc vous présenter ces deux méthodes l'une après l'autre, en vous expliquant leurs fonctionnements et en vous donnant le code Javascript nécessaire pour les mettre en place.

Debounce

Commençons par la fonction debounce. Cette technique a pour but de n'appeler qu'une seule fois une méthode au début ou à la fin d'une succession de déclenchements d'un événement. Voici tout d'abord le code source de la fonction en question :

/**
 * Retourne une fonction qui, tant qu'elle continue à être invoquée,
 * ne sera pas exécutée. La fonction ne sera exécutée que lorsque
 * l'on cessera de l'appeler pendant plus de N millisecondes.
 * Si le paramètre `immediate` vaut vrai, alors la fonction 
 * sera exécutée au premier appel au lieu du dernier.
 * Paramètres :
 *  - func : la fonction à `debouncer`
 *  - wait : le nombre de millisecondes (N) à attendre avant 
 *           d'appeler func()
 *  - immediate (optionnel) : Appeler func() à la première invocation
 *                            au lieu de la dernière (Faux par défaut)
 *  - context (optionnel) : le contexte dans lequel appeler func()
 *                          (this par défaut)
 */
function debounce(func, wait, immediate, context) {
    var result;
    var timeout = null;
    return function() {
        var ctx = context || this, args = arguments;
        var later = function() {
            timeout = null;
            if (!immediate) result = func.apply(ctx, args);
        };
        var callNow = immediate && !timeout;
        // Tant que la fonction est appelée, on reset le timeout.
        clearTimeout(timeout);
        timeout = setTimeout(later, wait);
        if (callNow) result = func.apply(ctx, args);
        return result;
    };
}

Pour mieux comprendre son fonctionnement, regardons le schéma ci dessous :

Chronogramme de la fonction debounce

Sur la première ligne de cette figure, chaque rectangle bleu représente un déclenchement de l’événement écouté (keydown par exemple). Lorsque deux déclenchements sont espacés par une durée inférieure à une valeur prédéfinie (paramètre wait), on va dire qu'ils appartiennent à une même séquence. Si la durée est supérieure, alors cela marque le début d'une nouvelle séquence.

Sur la deuxième ligne, les rectangles verts représentent les exécutions de la fonction "débouncé" (paramètre func). On remarque alors que la fonction debounce permet d'attendre la fin d'une séquence d'évènement pour effectuer le traitement associé. Si maintenant on reprend l'exemple de la synchronisation d'un champ de texte, cela signifie que l'appel AJAX sera effectué uniquement lorsque l'utilisateur cessera de modifier le contenu pendant une durée supérieure à wait.

Par ailleurs, dans certains cas, il peut être plus intéressant d'exécuter le traitement au début de la séquence plutôt qu'à la fin (comme le représente les rectangles violets). Cela est possible simplement en définissant le paramètre optionnel immediate à true.

L'utilisation concrète de cette fonction est assez simple. Voici un exemple :

function traiterEvenement() {
	// Fonction de traitement de l'évenement
        // (sauvegarde par appel AJAX par exemple)
}

// On limite l’exécution de la fonction traiterEvenement à une fois
// toutes les 5000 millisecondes (5s) au maximum.
var traiterEvenementDebounce = debounce(traiterEvenement, 5000);

// On s'enregistre sur l’événement de saisie clavier
document.querySelectorAll('#field')
        .addEventListener('keydown', traiterEvenementDebounce);

Cependant, ce mode de fonctionnement peut parfois poser problème. Ici par exemple, si l'utilisateur tape son texte en continu pendant plusieurs minutes, il ne sera pas sauvegardé sur le serveur puisque la séquence ne se termine pas. Selon les cas, cela peut être souhaitable ou gênant, c'est à vous de voir. Pour éviter cela, il y a deux solutions :

• Soit réduire l'intervalle entre les séquences (de 5s à 500ms par exemple), en se disant que l'utilisateur ne pourra pas taper longtemps sur son clavier sans jamais s'arrêter moins de 500ms. C'est plutôt vrai, mais du coup on augmente potentiellement le nombre d’exécutions, donc ça risque d'être plus lent et ça perd un peu de son intérêt...
• Soit utiliser la fonction throttle, qui propose un fonctionnement un peu différent.

Throttle

Parlons donc maintenant de la fonction throttle. Ici, comme le montre le chronogramme ci-dessous, on va exécuter la fonction de traitement de l'événement de manière périodique durant la séquence de déclenchements.

Chronogramme de la fonction throttle

Sur cette figure, les rectangles de couleur de la deuxième ligne représentes les exécutions de la fonction func. Attention, par défaut, seuls les rectangles violets sont effectivement exécutés. Pour inclure également les exécutions en début et/ou en fin de séquence (rectangles jaunes et verts), il faut définir respectivement les paramètres leading et/ou trailing à true.

Si on applique cette fonction à notre exemple, cela signifie que le texte du champ de saisie sera sauvegardé sur le serveur par un appel AJAX toutes les 5 secondes par exemple (paramètre wait), et ce tant que l'utilisateur change le contenu. Et si le texte n'est pas modifié, aucun appel n'est effectué. Ce comportement est donc idéal dans ce cas, puisqu'on limite le nombre d'appels au strict nécessaire pour ne pas risquer une perte de données.

Voici donc maintenant le code de la fonction throttle :

/**
 * Retourne une fonction qui, tant qu'elle est appelée,
 * n'est exécutée au plus qu'une fois toutes les N millisecondes.
 * Paramètres :
 *  - func : la fonction à contrôler
 *  - wait : le nombre de millisecondes (période N) à attendre avant 
 *           de pouvoir exécuter à nouveau la function func()
 *  - leading (optionnel) : Appeler également func() à la première
 *                          invocation (Faux par défaut)
 *  - trailing (optionnel) : Appeler également func() à la dernière
 *                           invocation (Faux par défaut)
 *  - context (optionnel) : le contexte dans lequel appeler func()
 *                          (this par défaut)
 */
function throttle(func, wait, leading, trailing, context) {
    var ctx, args, result;
    var timeout = null;
    var previous = 0;
    var later = function() {
        previous = new Date;
        timeout = null;
        result = func.apply(ctx, args);
    };
    return function() {
        var now = new Date;
        if (!previous && !leading) previous = now;
        var remaining = wait - (now - previous);
        ctx = context || this;
        args = arguments;
        // Si la période d'attente est écoulée
        if (remaining <= 0) {
            // Réinitialiser les compteurs
            clearTimeout(timeout);
            timeout = null;
            // Enregistrer le moment du dernier appel
            previous = now;
            // Appeler la fonction
            result = func.apply(ctx, args);
        } else if (!timeout && trailing) {
            // Sinon on s’endort pendant le temps restant
            timeout = setTimeout(later, remaining);
        }
        return result;
    };
};

L'utilisation de cette fonction est semblable à la fonction debounce, hormis les arguments optionnels qui sont différents. Voici un exemple :

function traiterEvenement() {
	// Fonction de traitement de l'évenement
        // (sauvegarde par appel AJAX par exemple)
}

// Ici il est utile d'activer le `trailing` pour traiter le dernier événement
var traiterEvenementThrottle = throttle(traiterEvenement, 5000, false, true);

// On s'enregistre sur l’événement de saisie clavier
document.querySelectorAll('#field')
        .addEventListener('keydown', traiterEvenementThrottle);

Les applications possibles de ces fonctions sont très nombreuses. Ici, j'ai pris l'exemple d'une fonctionnalité d'enregistrement automatique. Mais on peut aussi les utiliser pour repositionner des éléments lors du redimensionnement de la fenêtre, enregistrer des événements sur Piwik sans trop de répétitions, ...

Notez que certaines bibliothèques Javascript, comme Lodash ou UnderscoreJS, fournissent directement ces fonctions. Les implémentations que je vous propose ci-dessus en sont d'ailleurs inspirées. Inutile donc de les dupliquer si vous utilisez déjà une de ces bibliothèques pour votre application Web.

Enfin, bien que je parle ici de Web et de Javascript, je pense qu'il est tout à fait envisageable de reprendre le principe pour d'autres types de développement, y compris des applications bureaux en C++, C# ou Java par exemple. Étant donné la singularité de la syntaxe Javascript, il faudra en revanche revoir entièrement l'implémentation...

Voilà, j'espère que cet article vous aura aidé à comprendre l'utilité et le fonctionnement de ces fonctions. Si vous avez des questions, n'hésitez pas à me les poser en commentaire .

Maj 12/08/2015 :  En complément de cet article, je vous conseille de voir également ce tutoriel vidéo que l'ami Grafikart a publié ce jour.

La particularité de cette classe est qu'elle n'utilise pas une simple moyenne arithmétique pour déterminer la couleur dominante, contrairement à de nombreux scripts disponibles sur le web. En effet, cette méthode donne souvent des résultats plutôt aberrants, avec une couleur moche qui ne ressemble à rien de ce que l'on perçoit dans l'image. Ici, un algorithme avancé de quantification de couleurs est utilisé. Cet algorithme, nommé "Modified Mean Cut Quantizer", est comparable à celui utilisé par la compression JPEG. L'avantage est que les couleurs calculées sont le plus souvent visuellement très proches de celles présentes dans l'image d'origine, comme vous pouvez le voir sur l'exemple ci-dessous :

Un exemple de palette de couleurs obtenue grâce à Color Thief PHP

L'utilisation de la classe est très simple, surtout si vous utilisez Composer, mais peut être assez gourmande en ressources en fonction de la taille de l'image et de la qualité demandée. Je vous conseille donc de conserver le résultat en base de données plutôt que d’exécuter le script à chaque chargement de page. Pour plus d'informations, je vous invite à vous reporter à la documentation sur GitHub.

Les applications de cette classe ne sont limitées que par votre imagination : moteur de recherche par couleur, adaptation des couleurs de l'interface graphique en fonction de l'image affichée... Alex P. Gates a même développé un script PHP capable de modifier la couleur d'une lampe en fonction des couleurs d'une image, en utilisant Color Thief PHP et une lampe Philips Hue.

Enfin, si vous avez besoin de cet outil coté client en Javascript, sachez qu'il s'agit en fait d'un portage d'un script javascript. Vous pouvez donc utiliser le script Color Thief original réalisé par Lokesh Dhakar.

Ainsi, l'extrait de code ci-dessous est évidemment parfaitement valide et compile sans erreur :

for (int i = 0; i < 10; ++i) {
    std::cout << "Itération n°" << i << std::endl;
    int dummy;
    dummy = i * i;
    std::cout << "Le carré de " << i << " est " << dummy  << std::endl;
}

On note que la variable dummy est définie au milieu du code, sans que cela ne pose problème. Partant de ce constat, on pourrait croire que le code suivant compile également sans problème (en supposant que la variable choix est définie) :

switch (choix) {
    case 1:
        std::cout << "Choix 1." << std::endl;
        int dummy = time(NULL); // Erreur !!
        std::cout << "Il est " << dummy << std::endl;
        break;
    default:
        std::cout << "Choix inconnu." << std::endl;
        // std::cout << "Il est " << dummy << std::endl;
        break;
}

Et bien non ! Si vous compiler un code de ce genre, le compilateur le refusera en indiquant une erreur du type :

error: jump to case label
   crosses initialization of 'int dummy'

ou encore, selon les cas :

error: initialization of 'dummy' is skipped by 'case' label

La raison de cette erreur est que la portée de la variable définie à l'intérieur d'un case s'étend à l'ensemble du switch, et pas seulement à ce case. Le case n'est qu'un label, et ne limite pas la portée de la variable, qui n'est limitée que par les accolades englobantes du switch. Que se passerait il alors si le compilateur ne disait rien et que je décommentais la ligne 9 du code précédent ? Et bien, dans le cas où choix serait différent de 1, l'initialisation de la variable faite à la ligne 4 serait sautée puisque seul le bloc default serait exécuté. La variable dummy serait donc définie (puisque sa portée est globale à tout le switch) mais non initialisée (puisque l'initialisation n'a pas été exécutée). Dans cet exemple, dummy est un entier, il contiendrait simplement une valeur indéterminée. Mais ce pourrait tout aussi bien être un objet, et dans ce cas, le constructeur ne serait pas appelé si choix est différent de 1 ! Ce comportement risqué est donc interdit par le compilateur.

Pour résoudre ce problème, il faut explicitement limiter la portée de la variable en entourant le code du case par une paire d'accolades, comme ci-dessous :

switch (choix) {
    case 1:
    {
        std::cout << "Choix 1." << std::endl;
        int dummy = time(NULL); // Ok !!
        std::cout << "Il est " << dummy << std::endl;
        break;
    }
    default:
        std::cout << "Choix inconnu." << std::endl;
        // Désormais interdit car la variable est hors de portée !
        // std::cout << "Il est " << dummy << std::endl;
        break;
}

La portée de la variable dummy est ainsi limitée au case, et il devient impossible de l'utiliser dans un autre case.

Voilà pour cette petite astuce de programmation en C++ assez simple, il suffit juste d'y penser ! A noter que ce problème et sa solution s'applique aussi lorsque l'on déclare une variable entre un goto et le label ciblé par ce goto. Mais bon, c'est bien connu, plus personne n'utilise le goto de nos jours...

Source

Mais plutôt que de copier/coller ces faux paragraphes sans cesse, saviez-vous qu'il est possible de le "générer" facilement avec une ligne de code PHP ? C'est plus classe, ça prend moins de place dans le code côté serveur, et surtout vous pouvez l'utiliser pour remplir la base de données et pas seulement pour l'afficher directement !

Le suspens a assez duré, voici le code en question :

$lipsum = simplexml_load_file('http://www.lipsum.com/feed/xml?amount=1&what=paras&start=0')->lipsum;

Bon, ok, j'ai un peu triché. En réalité, on ne génère pas réellement le lipsum en PHP, mais on utilise plutôt l'API du site lipsum.com. Mais peu importe, le but principal est atteint, on a un faux texte en une ligne de PHP !

Pour allez plus loin, vous pouvez transformer cette simple ligne en une fonction un peu plus évoluée qui vous permettra de contrôler un peu plus de paramètres sur le texte généré :

function generer_lipsum($quantite = 1, $type = 'paras', $lorem = false) {
    $url = "http://www.lipsum.com/feed/xml?amount=$quantite&what=$type&start=".($lorem?'yes':'no');
    return simplexml_load_file($url)->lipsum;
}

Où les paramètres sont :

• $quantite : la quantité de texte à générer.
• $type : l'unité de comptage de la quantité de texte : paras pour paragraphes, words pour mots, bytes pour octets ou lists pour des listes HTML. Ainsi, si vous définissez $quantite à 5 et $type à words, vous allez générer une phrase aléatoire de 5 mots.
• $lorem : Si vrai, force le texte généré à débuter par "Lorem ipsum dolor sit amet...".

Voilà pour cette petite astuce qui me plait beaucoup et qui, je l'espère, vous plaira tout autant ! Et si vous en connaissez d'autres de ce style, n’hésitez pas à les partager en commentaire de cet article .

echo "toto" | tee monfichier

Permet donc d'afficher toto sur l'écran tout en l'écrivant dans le fichier monfichier. Si le fichier n'existe pas il sera créé, sinon son contenu sera écrasé.

Il est également possible de spécifier plusieurs fichiers :

echo "toto" | tee monfichier autrefichier encoreun

Enfin, si l'on souhaite ajouter la sortie aux fichiers indiqués plutôt que de les écraser, il faut spécifier l'option -a ou --append :

echo "toto" | tee -a monfichier autrefichier encoreun

Quelques options supplémentaires sont disponibles, voir le man de tee ! Pour se souvenir du nom de cette commande, on peut faire l'analogie avec un T de plomberie, en sachant que la lettre T se prononce tee en anglais