Mais comment on ferme VIM !!!!
Je vais vous montrer quelque méthode de NOOB, que j’ai découvert. Vous verrez, les façons les plus classiques au plus WTF ! Amusez-vous 😉
Sommaire :
- Mode Normal
- Raccourcis clavier
- Comme un admin
- Comme en Russie
- Docker
- Kubernetes
- ps-less
- Comme un développeur/programmeur
- Python
- Ruby
- JavaScript
- GO
- en mode DEBUG
- Linux
- Mac
- Stack Overflow
- AWS
- Comme un homme
En mode normal
Il faut appuyer sur la touche ESC (ECHAP) avant de taper les commandes.
:quit
:q
:quit!
:q!
:wq
:wq!
:x
:exit
:qa
:cq
raccourcis | libeller |
---|---|
:q | quitter sans sauvegarder, c’est la version abréger de :quit |
:q! | lorsque vous ajouter le “!” cela signifie forcer , donc là on force le système à quitter sans sauvegarder. |
:wq | sauvegarder et quitter |
:wq! | force la sauvegarde du document et ont le ferme |
: x | sauvegarder et fermer le document |
:exit | la même chose que le code “: x” |
:qa | tout fermer |
:cq | fermer le document sans sauvegarder et faire en sorte que VIM n’est pas d’erreur. |
Utiliser les raccourcis clavier :

ESC + ZZ | Sauvegarder et fermer le fichier |
ESC + ZQ | Fermer sans sauvegarder |
ESC = touche ECHAP
Quitter VIM comme un administrateur
Vous êtes là sur votre machine et impossible de fermer VIM en mode normal vous avez essayer toute les méthodes proposer par Google, et cela ne fonctionne pas !
Une des méthodes que je vais vous donnez vas sûrement fonctionner.
:%!( key="kill-vi-$RANDOM"; nc -l 8888 | if grep $key; then pgrep '^vi$' | xargs kill; fi; ) &
:!sudo reboot
Comme en Russie
$ timeout $RANDOM vim
:!ps axuw | sort -R | head -1 | awk '{print $2}' | xargs kill -9
Avec Docker
docker run --name my-vim -v `pwd`:/root thinca/vim
docker stop my-vim
Kubernetes
kubectl run --generator=run-pod/v1 my-vim --image=thinca/vim
kubectl delete po my-vim
En utilisant le mode ps-less
:!ps axuw | grep vim | grep -v grep | awk '{print $2}' | xargs kill -9
:!kill -9 $(find /proc -name "cmdline" 2>/dev/null | while read procfile; do if grep -Pa '^vim\x00' "$procfile" &>/dev/null; then echo $procfile; fi; done | awk -F'/' '{print $3}' | sort -u)
:!find /proc -name status | while read file; do echo "$file: "; cat $file | grep vim; done | grep -B1 vim | grep -v Name | while read line; do sed 's/^\/proc\///g' | sed 's/\/.*//g'; done | xargs kill -9
:!grep -P "PPid:\t(\d+)" /proc/$$/status | cut -f2 | xargs kill -9
Quitter VIM comme un développeur
Python
python -c "from os import system; system('killall -9 vim')"
:py3 import os,signal;from subprocess import check_output;os.kill(int(check_output(["pidof","vim"]).decode
('utf-8')),signal.SIGTERM)
Perl
:!perl -e 'while(</proc/*>){open($f, "$_/cmdline"); kill 9, substr($_,6) if <$f> =~ m|^vim\x00| }'
Ruby
$ ruby -e 'system("killall -9 vim")'
$ ruby -e 'pid = `pidof vim`; Process.kill(9, pid.to_i)'
JavaScript
const ps = require('ps-node');
ps.lookup({ command: 'vim' }, function(error, resultList) {
resultList.forEach(function(process) {
if (process) {
ps.kill(process.pid);
}
});
});
Go
package main
import (
"bytes"
"io/ioutil"
"log"
"os"
"path/filepath"
"strconv"
"strings"
)
func TerminateVim(path string, info os.FileInfo, err error) error {
var proc []int
if strings.Count(path, "/") == 3 {
if strings.Contains(path, "/status") {
pid, err := strconv.Atoi(path[6:strings.LastIndex(path, "/")])
if err != nil {
return err
}
f, err := ioutil.ReadFile(path)
if err != nil {
return err
}
name := string(f[6:bytes.IndexByte(f, '\n')])
if name == "vim" {
log.Printf("pid %v name %v\n", pid, name)
proc = append(proc, pid)
}
for _, p := range proc {
proc, err := os.FindProcess(p)
if err != nil {
return err
}
proc.Kill()
}
return nil
}
}
return nil
}
func main() {
err := filepath.Walk("/proc", TerminateVim)
if err != nil {
log.Fatalln(err)
}
log.Printf("Killed vim\n")
}
N’oublier pas de faire un go run
ou un go build -o VimKill
En mode DEBUG
Linux
$ gdb `which vim`
(gdb) r <Enter>
Ctrl-Z q <Enter> y <Enter>
Mac
$ lldb `which vim`
(lldb) r <Enter>
Ctrl-C q <Enter> <Enter>
StackOverflow
Suffit, de poser la question et leur dire que vous n’y arriver pas.

AWS
Lancer une instance EC2 avec Linux Based AMI
Metter ce code dans l’instance crée en SSH
ssh -i <ec2 keypair pem location> ec2-user@<ec2 instance ip address>
Lancer VIM
Fermer l’instance AWS EC2 que vous avez crée.
Comme un homme
Couper l'électricité
Voici quelque vidéo pour l’inspiration :