Emacs เทียบเท่ากับ VIM ci "?

emacs มีคำสั่ง VIMs ci "เทียบเท่าหรือไม่โดยทั่วไปฉันต้องการแทนที่ข้อความภายในชุดเครื่องหมายคำพูด

ในกลุ่มฉันสามารถ ci) หรือ ci] หรือ ci} เป็น "change inner *" ...

จากด้านบนของหัวคำสั่งที่ใกล้ที่สุดคือการM-z "ลบทุกอย่างจากจุดไปสู่การเกิดขึ้นครั้งถัดไปของตัวละคร "

นอกจากนี้ยังมีC-M-kaka "kill balance expression" ซึ่งจะลบคำสั่งวงเล็บเต็มหรือสตริงที่ยกมาสองครั้งเป็นต้นตามคำจำกัดความโหมดปัจจุบันของ "expression expression" และอักขระที่อยู่ภายใต้จุด (เช่นใช้งานได้เฉพาะเมื่อเคอร์เซอร์อยู่ อยู่ในการเปิด '"' หรือ '(' ฯลฯ )

ในทำนองเดียวกันกับข้อเสนอแนะของจัสติน CM-SPACE ให้ "mark-sexp" ซึ่งจะเลือกไปที่การทำสมดุลของคำพูด ฯลฯ จากนั้นคุณสามารถ Cw หรืออะไรก็ตามที่ทำให้มันหายไป ในกรณีที่คุณต้องการดูสิ่งที่คุณกำลังจะลบก่อนที่จะลบ ...

ใช่ คำสั่ง VIMs ci "เทียบเท่าใน Emacs คือ ... ci" :-)
http://www.emacswiki.org/emacs-de/Vimpulse

เพิ่งสะดุดกับคำถามนี้ นี่คือโซลูชันที่กำหนดเองที่เหมาะกับฉัน:

(defun seek-backward-to-char (chr)
  "Seek backwards to a character"
  (interactive "cSeek back to char: ")
  (while (not (= (char-after) chr))
    (forward-char -1)))


(defun delete-between-pair (char)
  "Delete in between the given pair"
  (interactive "cDelete between char: ")
  (seek-backward-to-char char)
  (forward-char 1)
  (zap-to-char 1 char)
  (insert char)
  (forward-char -1))

จากนั้นผูกการลบระหว่างคู่กับคีย์ที่คุณชอบ สำหรับฉันฉันมีข้อผูกมัดกับ Cz i

ฉันเกรงว่าฉันไม่รู้เกี่ยวกับคุณสมบัติ ci ของ VIM แต่คุณเคยดู Emacs regexp มาแทนที่หรือไม่? ฉันไม่สามารถพูดความหมายที่แน่นอนหรือเปรียบเทียบได้ง่าย แต่มันเป็นสิ่งที่ฉันจะใช้สำหรับสิ่งที่ฉันคิดว่าคุณต้องการ

• คู่มือ Emacs ในการเปลี่ยน regexp
• หมายเหตุเกี่ยวกับการจับคู่ regexp ของ Emacs
• การ์ตูนบังคับ

ผมได้ทำโหมดย่อยซึ่งมีบางส่วนของผู้อำนวยความสะดวกที่เป็นกลุ่มที่เรียกว่าMarkit

Magnars (ผู้เขียนเว็บไซต์ EmacsRocks) เขียนปลั๊กอินนี้เพื่อทำสิ่งที่คุณต้องการ

https://github.com/magnars/change-inner.el

เห็นได้ชัดว่าคุณสามารถใช้โหมดชั่วร้ายได้เช่นกัน

นี่คือเวอร์ชันของฉันที่จะลบทุกอย่างภายใน (หรือรวมถึง) อักขระที่ตรงกัน คู่อักขระถูกกำหนดในรายการเพื่อให้ทราบว่าเป็นอักขระเริ่มต้น / สิ้นสุดที่ตรงกัน ฉันทำแผนที่กับ "Cc i" เพื่อเปลี่ยนและ "Cc a" เพื่อเปลี่ยนทั้งหมด

นอกจากนี้ยังคัดลอกอักขระที่ลบไปยังบอร์ดคลิปเพื่อวางในภายหลัง

; Re-create ci" ca"...
(defun seek-backward-to-char (chr)
  "Seek backwards to a character"
  (interactive "cSeek back to char: ")
  (while (not (= (char-after) chr))
    (forward-char -1)))

(setq char-pairs
      '(( ?\" . ?\" )
        ( ?\' . ?\' )
        ( ?\( . ?\) )
        ( ?\[ . ?\] )
        ( ?\{ . ?\} )
        ( ?<  . ?>  )))

(defun get-char-pair (chr)
  (let ((result ()))
    (dolist (x char-pairs)
      (setq start (car x))
      (setq end (cdr x))
      (when (or (= chr start) (= chr end))
        (setq result x)))
      result))

(defun get-start-char (chr)
  (car (get-char-pair chr)))
(defun get-end-char (chr)
  (cdr (get-char-pair chr)))

(defun seek-to-matching-char (start end count)
  (while (> count 0)
    (if (= (following-char) end)
        (setq count (- count 1))
      (if (= (following-char) start)
          (setq count (+ count 1))))
    (forward-char 1)))

(defun seek-backward-to-matching-char (start end count)
  (if (= (following-char) end)
      (forward-char -1))
  (while (> count 0)
    (if (= (following-char) start)
        (setq count (- count 1))
      (if (= (following-char) end)
          (setq count (+ count 1))))
    (if (> count 0)
        (forward-char -1))))

(defun delete-between-pair (char)
  "Delete in between the given pair"
  (interactive "cDelete between char: ")
  (seek-backward-to-matching-char (get-start-char char) (get-end-char char) 1)
  (forward-char 1)
  (setq mark (point))
  (seek-to-matching-char (get-start-char char) (get-end-char char) 1)
  (forward-char -1)
  (kill-region mark (point)))

(defun delete-all-pair (char)
  "Delete in between the given pair and the characters"
  (interactive "cDelete all char: ")
  (seek-backward-to-matching-char (get-start-char char) (get-end-char char) 1)
  (setq mark (point))
  (forward-char 1)
  (seek-to-matching-char (get-start-char char) (get-end-char char) 1)
  (kill-region mark (point)))

(global-set-key (kbd "C-c i") 'delete-between-pair)
(global-set-key (kbd "C-c a") 'delete-all-pair)

นี่เป็นสิ่งที่ฉันขาดหายไปจาก Vim และzap-to-charดูเหมือนจะไม่ถูกต้อง

นี่คือความพยายามอันต่ำต้อยของฉันในการสร้าง "ci" และ "ca" ใหม่:

(defun change-outer (str)
  (interactive "sChange outer: ")
  (condition-case nil
      (search-backward str (line-beginning-position))
    (error (search-forward str (line-end-position))
       (forward-char -1)))
  (kill-sexp)
)

(defun change-inner (str)
  (interactive "sChange inner: ")
  (condition-case nil
      (search-backward str (line-beginning-position))
    (error (search-forward str (line-end-position))
       (forward-char -1)))
  (push-mark)
  (forward-sexp)
  (forward-char -1)
  (exchange-point-and-mark)
  (forward-char 1)
  (kill-region (point) (mark))
)

โดยทั่วไปแล้วไม่จำเป็นต้องมีเงื่อนไขของเคสเนื่องจากพารามิเตอร์ตัวที่สาม (เป็นทางเลือก) ของการค้นหาไปข้างหน้า / การค้นหาย้อนหลังนั้นหมายถึงการระบุสิ่งที่ต้องทำในกรณีที่การค้นหาล้มเหลว แต่ด้วยเหตุผลบางอย่างการวางการค้นหาครั้งที่สองเป็นพารามิเตอร์ที่สามสำหรับการค้นหาแรกทำให้เกิดพฤติกรรมที่แปลก

ฉันลองวิธีแก้ปัญหาที่นี่ แต่พบว่าพวกเขาต้องการวิธีใดวิธีหนึ่งดังนั้นฉันจึงได้สิ่งนี้ ยอมรับทั้งตัวคั่นเริ่มต้นหรือตัวคั่นและใช้ฟังก์ชัน Emacs ในตัวเพื่อหลีกเลี่ยงตารางการแปลสำหรับตัวคั่น

(defun change-inner (prefix character)
  "Kill region inside delimiters, using either beginning or
ending delimiter.  With prefix arg, kill including delimiters."

  (interactive "p\nc")
  (let ((initial-point (point))
        (start)
        (end)
        (move-point-by (if (> prefix 1) 0 1)))

    (condition-case nil
        (progn
          ;; Search forward for given char
          (search-forward (char-to-string character))
          (setq end (- (point) move-point-by))

          (condition-case nil
              (backward-sexp)
            (error (backward-list)))

          (setq start (+ (point) move-point-by))
          (kill-region start end)
          (or prefix (forward-char)))

      (error (progn
               ;; Reset and search backward for given char
               (goto-char initial-point)
               (search-backward (char-to-string character))
               (setq start (+ (point) move-point-by))

               (condition-case nil
                   (forward-list)
                 (error (forward-sexp))))

             (setq end (- (point) move-point-by))
             (kill-region start end)
             (or prefix (backward-char))))))
(global-set-key (kbd "M-i") 'change-inner)

(defun change-outer ()
  (interactive)
  (let ((current-prefix-arg '(4)))
    (call-interactively 'change-inner)))
(global-set-key (kbd "M-o") 'change-outer)