如果你输入如下的表达式：

(let [x "foo bar baz ... blah"])
                         ^

而且你希望可以移动到字符串的开头：

(let [x "foo bar baz .... blah"])
         ^

只需调用 sp-beginning-of-sexp,我把这个函数绑定到了快捷键 C-M-a; 相反地，如果你想把光标移动到字符串的结尾：

(let [x "foo bar baz .... blah"])
                              ^

只需调用 sp-end-of-sexp,我把该函数绑定到了快捷键 C-M-e.

如果你输入如下的表达式：

(defun format-data(format)
  (let ((system-time-locale "en_US.UTF-8"))
    (insert (format-time-string format)))) ^

而你想把光标移动到 insert:

(defun format-data(format)
  (let ((system-time-locale "en_US.UTF-8"))
    (insert (format-time-string format))))
     ^

只需执行 sp-down-sexp,我把这个函数绑定到了 C-down 如果你有如下的表达式：

(str "foo" "bar baz qux")
    ^ 

而你想把光标移动到 ) 的后面：

(str "foo" "bar baz qux")
                         ^ 

只需调用 sp-up-sexp,我把该函数绑定到了快捷键 C-up 如果你有如下的表达式：

(defn foo [bar] (let [x 0] x))
                ^

而你想把光标移动到 ] 后面：

(defn foo [bar] (let [x 0] x))
              ^ 

你只需调用 sp-backward-down-sexp,我把该函数绑定到了快捷键 M-down 如果你有如下的表达式：

(insert (format-time-string format))
                           ^

而你想把光标 (format 的( 上：

(insert (format-time-string format))
        ^

你只需调用函数 sp-backward-up-sexp.我把该函数绑定到了快捷键 M-up

如果你有如下的表达式

(:require [clojure.string :as s])
          ^

而你想把光标移动到 ] 后面：

(:require [clojure.string :as s])
                                ^

你只需调用 sp-forward-sexp,我把该函数绑定到了快捷键 C-M-f 相反地；如果你想移动到 [:

(:require [clojure.string :as s])
          ^

只需调用 sp-backward-sexp,我把该函数绑定到了快捷键 C-M-b

假设你有如下表达式：

(defn blah
  "Returns blah of foo."
  [foo]                 ^
  )

而你想把光标移动到 [ :

(defn blah
  "Return blah of foo."
  [foo]
  ^
  ) 

你只需调用函数 sp-next-sexp,我把该函数绑定到了 C-M-n 相反地，如果我想把光标移动回来：

(defn blah
  "Returns blah of foo."
  [foo]                 ^
  )

只需调用函数 sp-previous-sexp,我把该函数绑定到了 C-M-p

假设你有如下的表达式：

(defn blah [] (let [x 0 y 1](+ x 1)))
               ^

而你想把光标移动到 blah:

(defn blah [] (let [x 0 y 1](+ x 1)))
      ^

你只需调用函数 sp-backward-symbol,我把该函数绑定到了 M-S-b 此外，假设你有如下的表达式

(defn blah [] (let [x 0 y 1](+ x 1)))
            ^

而你想把光标移动到 (let 后面：

(defn blah [](let [x 0 y 1](+ x 1)))
                 ^

你只需调用函数 sp-forward-symbol,我把该函数绑定到了 C-S-f

上述各种函数所做的就是在表达式直接跳转，就好像分隔符（例如括号，方括号，花括号） 不存在那样。

假设你有如下的表达式：

var mods="vars";
         ^

而你想将 vars 包裹在 [] 里面：

var mods=["vars"]
          ^

按下 C-M-Space,然后在按下 [, vars 就会被一对 [] 所包裹；此外你同样 可以使用 (, { , ", ', _,等符号实现你想要的效果。 此外，你也可以定义相应的函数来简化按键操作：

(defmacro def-pairs (pairs)
  "Define functions for pairing. PAIRS is an alist of (NAME . STRING)
conses, where NAME is the function name that will be created and
STRING is a single-character string that marks the opening character.

  (def-pairs ((paren . \"(\")
              (bracket . \"[\"))

defines the functions WRAP-WITH-PAREN and WRAP-WITH-BRACKET,
respectively."
  `(progn
     ,@(loop for (key . val) in pairs
             collect
             `(defun ,(read (concat
                             "wrap-with-"
                             (prin1-to-string key)
                             "s"))
                  (&optional arg)
                (interactive "p")
                (sp-wrap-with-pair ,val)))))

(def-pairs ((paren . "(")
            (bracket . "[")
            (brace . "{")
            (single-quote . "'")
            (double-quote . "\"")
            (back-quote . "`")))

(译者注：如果你运行上面的函数出错，可以添加一条语句 (require 'cl)) 我把前面三条函数绑定到了按键 C-c ( C-c [ C-c {.所以如果你有如下函数：

(defn foo args (let [x 0](inc x)))
          ^

你想用 [] 包裹住 args

(defn foo [args](let [x 0](inc x)))
           ^

你现在只需按下 C-c [. 有时候，我们无意间会输错了符号对中的其中一个符号，从而导致符号对的不匹配。现在， 你有了 smartparens, smartparens 会阻止这样的事情发生；例如你在下面的表达式 按下 Backspace

var mods=["vars"]
          ^ 

什么都不会改变。 smartparens 真的帮我们省去了很多烦恼

如果你有如下的表达式：

(foo (bar x y z))
     ^

而你想去掉 foo 外面的那层括号：

foo (bar x y z)
    ^

你只需调用函数 sp-backward-unwrap-sexp,我把该函数绑定到了 M-[; 此外，如果你想去掉 bar 外面的那层括号：

(foo bar x y z)
     ^

你只需调用 sp-unwrap-sexp,我把该函数绑定到了 M-]

假设你有如下的表达式：

[foo bar] baz
        ^ 

而你想把 baz 放到方括号里面

[foo bar baz]
        ^

你只需 sp-forward-slurp-sexp,我把该函数绑定到了 C-right 此外；如果你又想把 baz 拿出来：

[foo bar] baz
        ^

你只需调用 sp-forward-barf-sexp,我把该函数绑定到了 M-right. 假设你有如下的表达式：

blah [foo bar]
             ^

而你想把 blah 放到方括号里面：

[blah foo bar]
             ^ 

你只需调用 sp-backward-slurp-sexp,我把该函数绑定到了 C-left 此外，如果你想把 blah 重新拿出来：

blah [foo bar]
             ^

你只需调用函数 sp-backward-barf-sexp,我把该函数绑定到了 M-left

假设你有如下的表达式：

"foo" "bar"
      ^

而你想把 foo 和 bar 交换位置：

"bar" "foo"
      ^

你只需调用函数 sp-transpose-sexp,我把该函数绑定到了 C-M-t

假设你有如下的表达式：

(let [x "xxx" y "y yy yyy" z 0])
               ^

而你想删除掉 y yy yyy:

(let [x "xxx" y z 0])
               ^

你只需调用 sp-kill-sexp,我把该函数绑定到了 C-M-k 或者你想删除 "y yy yyy" z 0:

(let [x "xxx" y])
               ^

你只需调用函数 sp-kill-hybrid-sexp,我把该函数绑定到了 C-k

假设你有如下的表达式：

(:require [clojure.string :as s])
                                ^ 

而你想删除掉 [clojure.string :as s]:

(:require)
         ^

你只需调用函数 sp-backward-kill-sexp,我把该函数绑定到了 M-k