Comment quitter VIM, comme une NOOB ?

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 😉

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

Utiliser les raccourcis clavier :

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 :

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.