Grub permet d’avoir au démarrage le choix du système d’exploitation que l’on souhaite lancer. Il est automatiquement installé lorsque l’on installe linux en tout cas pour Linux Mint (basé sur Ubuntu).
Il peut être intéressant d’avoir grub sur une partition en dehors de linux pour par exemple modifier le fichier de démarrage grub.cfg depuis Windows ou pour pouvoir formater linux et avoir un Grub qui fonctionne toujours. Un exemple d’utilisation sera montré à la fin avec un script qui permet de redémarrer depuis Linux vers Windows et Inversement.

Nous supposons ici que votre ordinateur est équipé de EFI (norme datant de 2006).  Pour éviter tout problème veuillez sauvegarder les fichiers que vous ne souhaitez pas perdre.  Il se peut que vous n’arriviez plus à booter suite à ces opérations, il est vivement conseillé d’avoir accès à une live-usb linux-mint bootable qui permettra d’installer  et lancer boot-repair qui marche plutôt bien pour réparrer GRUB. Une clef usb super grub2 disk peut aussi être pratique pour démarrer sur votre Linux même si le grub est cassé. Vous pouvez mettre les deux sur la même clef grace à Yumi (si la clef ne boot pas il faut peut être copier le dossier EFI d’une clef linux qui boot sur votre clef). Dans tous les cas si vous suivez ces instructions, c’est à vos risques et périls et je ne pourrait être tenu responsable.

Si vous avez déjà un Grub fonctionnel nous allons voir comment le déplacer sur une partition externe sinon une procédure complète d’installation sera aussi fournit.

Tout d’abord créer une partition en Fat32 avec Gparted sous linux.
Ajouter un label et nommer votre partition « GRUB » et mettre de coté son UUID ce disque est chez moi /dev/sdb3
Repérer quelle est votre partion EFI pour moi c’est /dev/sdb1

maintenant on va déplacer notre le grub installé de base dans /boot/grub dans /dev/sdb3

efi=/dev/sdb1
efiMount=/media/efi
partition=/dev/sdb3
partitionMount=/media/GRUB

#on crée nos dossier pour monter nos disques
sudo mkdir -p « $partitionMount » « $efiMount »
#on monte le disque
sudo mount « $partition » « $partitionMount »
#on déplace tout sur la nouvelle partition.
sudo mv /boot/grub/* « $partitionMount »

#on monte l’efi
sudo mount « $efi » « $efiMount »

Maintenant qu’on a déplacer nos fichiers grub il faut dire à l’EFI où ils sont.
Il faut maintenant repérer dans /media/efi où est grub.cfg (c’est pas le même que celui dans le dossier GRUB) ou était le dossier de votre Linux, pour moi c’est /media/efi/EFI/ubuntu/grub.cfg

Si vous n’avez pas sublime Text remplacer subl par nano.

sudo subl /media/efi/EFI/ubuntu/grub.cfg

Et là il faut remplacer le UUID par le UUID de votre partition ou vous avec déplacé  Grub  que je vous avez dit de mettre de coté si vous ne l’avez pas fait, on peut le retrouver avec blkid. Attention il faut prendre UUID et non le PART-UUID.

Il faut aussi changer la ligne de prefix comme ceci car on a mis tous les fichier à la base de la partition
set prefix=($root)’/’

enregistrer et redémarrer ça devrait être bon.

Si la procédure ci-dessus ne fonctionne pas ou si vous n’avez pas grub installé. voici la réinstallation complète. (si votre Grub n’est pas à jour ou votre EFI endommagé un grub -repair est nécessaire).
Bien sûr remplacer les variables, partiton,efi, disk. Disk étant comme partition mais sans le chiffre à la fin.

partition=/dev/sdb3
efi=/dev/sdb1
disk=/dev/sdb
efiMount=/media/efi
partitionMount=/media/GRUB
sudo fatlabel "$partition" GRUB
sudo umount "$partition"
sudo mkdosfs -F 32 "$partition"
sudo umount "$efi"
sudo rm -Rf "$partitionMount"
sudo mkdir -p "$partitionMount" "$efiMount"
sudo mount "$partition" "$partitionMount"
sudo mkdir -p "$partitionMount"/boot/grub
sudo mount "$efi" "$efiMount"
sudo grub-install --no-floppy --boot-directory="$partitionMount"/boot --efi-directory="$efiMount" "$disk"
sudo grub-mkconfig -o "$partitionMount"/boot/grub/grub.cfg
update-grub

A partir de ce moment vous avez un grub fonctionnel mais l’arborescence des fichier ne me plait pas et je prefère avoir les fichier de grub à la racine.

sudo mv « $partitionMount »/boot/grub/* « $partitionMount »/

Là encore il faut changer le prefix de notre grub dans le grub.cfg de EFI
sudo subl /media/efi/EFI/ubuntu/grub.cfg #remplacer subl par nano si vous n’avez pas sublime text
et changer la ligne 2 sur le prefix pour avoir
set prefix=($root)’/’

Maintenant nous allons faire un petit script pour redémarrer d’un OS vers un autre.

Créer un dossier dans la partition ou vous avez mis grub nommé Script.
dedans créer un script « shutdownTo.sh »

avec ce contenu:
OS="$1" # "Windows" Or "Linux" OR "CLOVER" ..."
shutOrReboot="$2" #"shutdown" Or "reboot"
grubFold=$(dirname "$0")/..
grubLoca="${grubFold}/grub.cfg"
#on fait un backup de grub.cfg à la fin de grubBackup, just in case
echo "#### new backup ####" | cat - "$grubLoca" >> "${grubFold}/grubBackup.cfg"
#checher le numéro du menu contenant le nom de $OS
newEntry=$(grep -i "menuentry ['\"]" "$grubLoca" | egrep -n "${OS}"|cut -f1 -d:| head -n1)
#la ligne 1 correspond à l'indice 0 de notre menu donc on enlève 1
#remplacer dans grub.cfg l'entrée par défaut par $newEntry -1
sed -i -E "s/default=\"[0-9]+?\"/default=\"$(($newEntry - 1))\"/" "$grubLoca"
#umount /dev/sdb3
if [ "$shutOrReboot" = "shutdown" ]
then
shutdown -f -p #windows
shutdown -f 0 #linux
fi
if [ "$shutOrReboot" = "reboot" ]
then
reboot -f -p -r
reboot -f -r 0
fi

voici comment il s’utilise
sudo sh /media/GRUB/Script/shutdownTo.sh Windows reboot # pour rebooter vers windows
sudo sh /media/GRUB/Script/shutdownTo.sh Linux reboot # pour rebooter vers linux
sudo sh /media/GRUB/Script/shutdownTo.sh Linux shutdown # pour éteindre et au prochain démarrage avoir linux
sudo sh /media/GRUB/Script/shutdownTo.sh Windows shutdown # pour éteindre et au prochain démarrage avoir Windows
sudo sh /media/GRUB/Script/shutdownTo.sh Windows # au prochain démarrage avoir Windows mais ne pas éteindre

On est obligé d’utiliser sh car sur un fat32 les fichier ne peut pas avoir des droits d’exécution comme sur un ext2/3/4
Bien sur vous n’aller pas taper ça à chaque fois sur le bureau créez-vous un lanceur « clic droit sur le bureau et créer un nouveau lanceur et mettre dans commande la ligne souhaitez. Il suffira alors de double cliquer sur le lanceur pour avoir l’opération choisi.

Pour Windows j’utilise personnellement gitBash qui s’installe avec GIT, mais d’autre solutions existes.
vous pouvez créer un fichier bat qui conteint ceci.
« \Program Files\Git\bin\bash.exe » –login « E:\boot\grub\Scripts\shutdownTo.sh » Linux

Si vous mettez ce fichier dans /media/…/Users/…/Application Data/Microsoft/Windows/Start Menu/Programs/Startup

Dès que vous démarrerez Windows vous setterez (oui je conjuque de l’anglais en français) le prochain OS à démarré à windows.

Vous pouvez aussi avoir des raccouris pour redémarrer sous linux depuis windows comme ceci

"\Program Files\Git\bin\bash.exe" --login "E:\boot\grub\Scripts\shutdownTo.sh" Linux reboot


Le parcours d’un objet pour le copier peut se faire facilement via un for in exemple:

var a = {
b:"a",
c:"e"
}
var copie = {};

for(var i in a){
copie[i] = a[i]
}

le problème est que le for in parcours aussi les propriétés hérités et donc les méthodes. Si on voulais ne par copier les propriétés hérités cela donnerait
for(var i in a){
if(a.hasOwnProperty(i)){
copie[i] = a[i]
}
}
mais là les performances sont encore plus mauvaises.
Une solution est d’utiliser Object.keys (ie9+) pour récupérer les clef de l’objet.

var keys = Object.keys(obj);
var lg = keys.length
for (var i = 0; i < lg; i++){
var o = keys[i];
copie[o] = a[o];
}
ça risque d'être un peu long à chaque fois de réécrire tout ça faisons en une fonction:

var forOf =function(obj, func){
var keys = Object.keys(obj);
var lg = keys.length
for (var i = 0; i < lg; i++){
var o = keys[i];
func(obj[o], o, obj);
}
}

et l'appel pour la copie par exemple
forOf(a,function(obj,i){
copie[i]=obj;
})

Si la fonction s'appelle for of c'est car les vrai navigateurs supporte cette propriété https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/for...of

l'utilisation de cette fonction pour les boucles va vous permettre d'optimiser vos performances par deux https://jsperf.com/object-keys-iteration/20 sauf sur ie apparemment en ne testant pas que l'objet est pas hérité ou on perd quelques pourcentages négligeables.

Un petit article pour partager un script pour faire des classes façon java avec un générateur de getteur setteur intégré
https://github.com/bormat/ClassEtHeritage
exemple d’utilisation :

Class.create("classe1",{
extend:Object,
initialize:function (a,b){
this._a=2;
this._b=5;
},
getteurEtSetteur:"a,b"
})

Class.create(« classe2″,{
extend:classe1,
initialize:function (a,b){
$super(a,b);
this._c=4;
},
getteur: »c »,
setteur: »c »
})

initialize est le constructeur
extend la classe parente,
$super appelle la même méthode mais dans la classe parente elle doit forcément être appelé au début de la fonction
getteurEtSetteur: accesseur à this_nomVarriable en lecture ecriture exemple si on metteur getteurEtSetteur: »c » on peut faire

var o=new classe2;
o.setC(5);
o.getC();//retourne 5;

on peut aussi ne faire que le getteur ou que le setteur.

Bonjour à tous,
La méthode proposée nécessite IE 11 minimum ou tout autre navigateur récent. Si vous avez besoins de gérer les versions antérieurs de IE lisez cet article en anglais qui explique la complexité et les différentes solutions au problème.
Peut être avec vous déjà vu ce genre de code  sur internet permettant de rajouter une fonction à tous les tableaux

Array.prototype.uneFonctionQuiDevraitPasEtreLa = function(){
//UNE ACTION
}

Le code ci-dessus marchera bien pour tous les tableaux mais il y a des risques de collisions si un autre développeur à déjà étendu le prototype de Array.

Je suis sur que  rajouter des fonctions directement à une ArrayList en java ne vous serez jamais venus à l’esprit, au lieu de cela vous auriez créer votre propre classe héritant de ArrayList.

C’est aussi possible en javaScript( ie11+, chrome, firefox) avec ce code.

var TabSousClass = function(tab){
    tab = tab || [];
    tab.__proto__ = TabSousClass.prototype;
    return tab;
}
TabSousClass.prototype.__proto__= Array.prototype
TabSousClass.prototype.suppElmt=function(elmt){
    return this.splice(this.indexOf(elmt),1);
}

TabSousClass est notre constructeur et sous CLasse de Array.
Maintenant une version un peu plus commenté avec un exemple si vous avez besoins:

//sous classe de Array
var TabSousClass = function(tab){
    tab = tab || [];
    tab.__proto__ = TabSousClass.prototype;
    //un exemple de constructeur par defaut
    instance.push(8,9)
    instance[50]=0; //instance.length == 51 comme pour un tableau
    //fin exemple
    return tab;
}

//heritage habituel équivalent de
//TabSousClasse.prototype = Object.create(Array.prototype)
TabSousClass.prototype.__proto__= Array.prototype

//exemple de fonction rajouté seulement aux instances de
//TabSousClass et non à tous les tableaux
//supprime un objet d’un tableau et le retourne, fonction qui
//bizarrement n’est pas implémenté de base

TabSousClass.prototype.suppElmt=function(elmt){
    return this.splice(this.indexOf(elmt),1);
}

//une instance de ma sous classe
var instSousTab = new TabSousClass();
instSousTab.push(10)
instSousTab[56]= "hello" //length 57

alert("instSousTab instanceof Array : "+(instSousTab instanceof Array)+"\n"+
"instSousTab instanceof TabSousClass : "+(instSousTab instanceof TabSousClass)+"\n"+
"contenu Tableau " + instSousTab +"\n"+
"instSousTab.length " + instSousTab.length +"\n"
 );

TabSousClass est votre Class héritant de tableau et aussi le constructeur vous pouvez modifier ce qu’il y a entre les 2 commentaires pour faire vos propres initialisationss, mais je vois très peu de cas d’utilisation.

Expliquation de newSubTab :

D’ habitude lorsque l’ont fait un new sur une function() on obtient un objet.
durant ce new il se passe 2 choses:
– le constructeur (la fonction) est appelé et return un objet.
– la référence du prototype de la classe ( objet contenant toute les fonction de la classe) est affecté au __proto__ de notre objet.

Sauf que si on ne met pas de return dans notre constructeur, le constructeur nous retourne le this de la fonction qui est un objet héritant (cad avec le __proto__ de l’objet = au prototype de ) de Object.
Nous souhaitons avoir un Array il faut retourner un array dans le constructeur.
il suffit alors avant de le retourner de dire que ce tableau est une instance de notre classe comme ceci

f.__proto__ = Class.prototype;

 Attention : Le Paramètre du constructeur change de type donc si ce n’est pas le comportement souhaité vous devez créer une copie préalablement. Si c’est le comportement souhaité on peut aussi se passer de l’opérateur new comme ceci.

tab=[1,2] // tab instanceof Array
TabSousClass(tab) //tab instanceof TabSousClass

L’avantage d’avoir un loader pour angularjs  est pour les  tests car vous n’aurais à charger qu’ un seul fichier js dans vos test et votre véritable application AngularJs. Ce Js nous l’appellerons loader. Le principe est de charger angular normalement mais avec un contrôleur vide, on récupère le scope du contrôleur et on le remplit plus tard une fois tous nos script chargés.

Html :

<head>
    <script src="http://code.angularjs.org/1.2.16/angular.min.js"></script>
    <script src="controller.js"></script><!--le factice-->
    </head>
    <body>
    <div ng-controller="planController" ng-app="planning">
        {{message}}
    </div>
    <script src="loader.js"></script>
</body>

Le contrôleur factice vide: controller.js

var publicAccessToScope;
angular.module('planning', ['mod']);
var mod = angular.module('mod',[]);
mod.controller('planController',function($scope){//ne pas changer $scope
    publicAccessToScope= $scope;
});

Le vrai controleur:  controllerImpl.js

void function controlleur ($scope){//ici $scope peut être remplacé par un nom plus court
var $scope = $scope || {} //si vous faite des tests de controleur
$scope.message = "test2"
$scope.$apply();
return $; //si vous faite des tests de controleur
}(publicAccessToScope)

Un petit loader pas du tout optimisé: 

function load(arg,dossier){
    arg = arg.split(",");
    for (var i in arg){
        var script = document.createElement("script");
        script.src = dossier + arg[i] + ".js";
        document.body.appendChild(script);
    }
}
//juste un exemple de script à charger ici dans le répertoire js
load("serialisation,ElementGraphique,Planning,Colonne,Evenement,Periode,Graphique,Categorie,Page","js/")

load("controllerImpl","./")// le vrai controleur