Emacs 切换到前一个窗口

That'd be C-- C-x o

In other words, C-x o with an argument of -1. You can specify how many windows to move by inserting a numeric argument between C-u and the command, as in C-u 2 C-x o. (C-- is a shortcut for C-u - 1)

You might also want to try using windmove which lets you navigate to the window of your choice based on geometry. I have the following in my .emacs file to change windows using C-x arrow-key.

(global-set-key (kbd "C-x <up>") 'windmove-up)
(global-set-key (kbd "C-x <down>") 'windmove-down)
(global-set-key (kbd "C-x <right>") 'windmove-right)
(global-set-key (kbd "C-x <left>") 'windmove-left)

Base on idea from @Nate but slightly modified to support backwards cycling between windows

;; Windows Cycling
(defun windmove-up-cycle()
(interactive)
(condition-case nil (windmove-up)
(error (condition-case nil (windmove-down)
(error (condition-case nil (windmove-right) (error (condition-case nil (windmove-left) (error (windmove-up))))))))))


(defun windmove-down-cycle()
(interactive)
(condition-case nil (windmove-down)
(error (condition-case nil (windmove-up)
(error (condition-case nil (windmove-left) (error (condition-case nil (windmove-right) (error (windmove-down))))))))))


(defun windmove-right-cycle()
(interactive)
(condition-case nil (windmove-right)
(error (condition-case nil (windmove-left)
(error (condition-case nil (windmove-up) (error (condition-case nil (windmove-down) (error (windmove-right))))))))))


(defun windmove-left-cycle()
(interactive)
(condition-case nil (windmove-left)
(error (condition-case nil (windmove-right)
(error (condition-case nil (windmove-down) (error (condition-case nil (windmove-up) (error (windmove-left))))))))))


(global-set-key (kbd "C-x <up>") 'windmove-up-cycle)
(global-set-key (kbd "C-x <down>") 'windmove-down-cycle)
(global-set-key (kbd "C-x <right>") 'windmove-right-cycle)
(global-set-key (kbd "C-x <left>") 'windmove-left-cycle)

If you work with multiple emacs windows (>3) a lot and you will want to save some keystrokes add this to your init file and you'll be better off:

(defun frame-bck()
(interactive)
(other-window-or-frame -1)
)
(define-key (current-global-map) (kbd "M-o") 'other-window-or-frame)
(define-key (current-global-map) (kbd "M-O") 'frame-bck)

Now just cycle quickly thru the windows with M-o

Personally I prefer to use window-number.el

To select a different window, use Ctrl-x, Ctrl-j n

Where n is the number of the window, the modeline of each window shows it's number, as shown in the screenshot.

Just download window-number.el, place it in your emacs load-path and use the following in your .emacs

 (autoload 'window-number-mode "window-number"
"A global minor mode that enables selection of windows according to
numbers with the C-x C-j prefix.  Another mode,
`window-number-meta-mode' enables the use of the M- prefix."
t)

There's another similar mode called switch-window.el which gives you big numbers in the windows... (pressing the number switches the window and reverts the display.)

_{(source: tapoueh.org)}

There is already a package that lets you switch windows by using M-. check this website. Add this to your init file:

(require 'windmove)
(windmove-default-keybindings 'meta) ;; or use 'super to use windows key instead alt

Just to add to @Nate, @aspirin and @Troydm's answer I find this to be a very helpful addition if you decide to bind the windmove commands to whatever key combination you choose:

(setq windmove-wrap-around t)

With the default configuration you will get an error when you get to attempt to move to a window that doesn't exist which becomes kind of annoying after a while. However when windmove-wrap-around is set then attempting to move off the bottom of the frame for example will instead select the topmost window in the frame. This may be a more intuitive behaviour for you.

There are some very good and complete answers here, but to answer the question in a minimalist fashion:

 (defun prev-window ()
(interactive)
(other-window -1))


(define-key global-map (kbd "C-x p") 'prev-window)

M-n and M-p makes the most sense to me, since they are analogous to C-n (next-line) and C-p (previous-line):

(define-key global-map (kbd "M-p") 'previous-multiframe-window)
(define-key global-map (kbd "M-n") 'other-window)

(inspired by to this and that)

In reference to Nate's answer, I replaced the arrow keys to use the traditional p for going up, n for going down, f for going right and b for going left. I also replaced the Ctrl with p0 key as p1 are the default movement keys. This combination with p2 lets you jump characters and lines instead of going through just one by one after each keystroke. Thus p0 key felt the best choice to keep it an easy key binding. Also, now you don't have to take your hand off the home row any more!

(global-set-key (kbd "s-p") `windmove-up)
(global-set-key (kbd "s-n") `windmove-down)
(global-set-key (kbd "s-f") `windmove-right)
(global-set-key (kbd "s-b") `windmove-left)

Hope it helps!

(global-unset-key (kbd "M-j"))
(global-unset-key (kbd "M-k"))
(global-set-key (kbd "M-j") (lambda () (interactive) (other-window 1)))
(global-set-key (kbd "M-k") (lambda () (interactive) (other-window -1)))

altj and altk will cycle through your visibles buffers. Forwards and backwards, to be exact.

(global-set-key (kbd "C-x a") 'ace-swap-window)
(global-set-key (kbd "C-x q") 'ace-select-window)


download ace-window from the melpa repo if you don't know how to do that
put this in your .emacs file if you don't have one create it


(package-initialize)


(require 'package)
(add-to-list 'package-archives '("melpa" , "http://melpa.org/packages/"))


(package-initialize)


then "m-x list-packages"

The fastest method I have found for switching to the previous window is to mash a couple keys together as a "key-chord". The following lets you use your left pinky+ring fingers together to go to previous window:

(key-chord-define-global "qw" 'prev-window)
(key-chord-define-global "'y" 'other-window) ; bonus for my colemak, adjust otherwise
(key-chord-define-global ";'" 'other-window) ; probably normal

(This is possible because Emacs key chords are order independent, meaning that qw is the same as wq.)