footer logo

You can have anything you want in life if you dress for it.

exit vim
Photo by Dongki Koh on Unsplash

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 :

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
raccourcislibeller
:qquitter 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.
:wqsauvegarder et quitter
:wq!force la sauvegarde du document et ont le ferme
: xsauvegarder et fermer le document
:exitla même chose que le code “: x”
:qatout fermer
:cqfermer le document sans sauvegarder et faire en sorte que VIM n’est pas d’erreur.

Utiliser les raccourcis clavier :

la Touche ESC / ECHAP est en haut à gauche. (avant la touche F1)
ESC + ZZSauvegarder et fermer le fichier
ESC + ZQFermer 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.

Quitter VIM avec la commande
:q!

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 :

Je ne vous ai pas citer toute les autres méthode, mais oui il existe plus de 1000 façons différente de quitter VIM. C’est à vous de choisir la méthode, la plus adapter à votre situation.