3

中に置換する部分式を対象とする既存のパッケージはあり query-replace-regexpますか?

たとえば、次の場合

var foo1 = blah( properties, property_id);

var foo2 = blah(properties, property_id );

var foo3 = blah(  properties, property_id      );

ブレースの周りのパディングを削除したい。

通常、保持したいビットをサブグループ化し、代替品を組み立てる方法です。

探す：

\(var .* = blah\s-*(\)\s-*\(.*?\)\s-*\()\)

交換：

\1\2\3

ただし、削除したいビットをグループ化する正規表現を使用する方が、その逆よりもはるかに簡単なようです。このように：

var .* = blah\s-*(\(\s-*\).*?\(\s-*\))

これから 2 つのサブグループを取得します。それらを交換の対象にするにはどうすればよいですか?

編集:指定された正規表現を「反転」するインタラクティブな方法を求めています。したがって、インターフェースは次のようになりますquery-replace-regexp

  1. 正規表現を入力してください
  2. グループ 1 の代替を入力してください
  3. グループ 2 の代替を入力してください
4

2 に答える 2

1

これのいくつかのバリエーションが機能するはずだと思います：

(defun remove-padding ()
  (interactive)
  (while (search-forward-regexp
          "var .* = [a-zA-Z_]+\\s-*(\\(\\s-*\\).*?\\(\\s-*\\))"
          nil t)
    ;; Replace the 2 subexpressions with nothing
    (replace-match "" nil t nil 2)
    (replace-match "" nil t nil 1)))

ただし、ユースケースによっては、インデントなどのツールの使用を検討することもできます。

編集: 以下は非常に最小限のインタラクティブなバージョンです。この関数query-replace-regexpは非常に複雑で、すべての機能を再現しようとはしていません。

(require 're-builder)
(defun query-replace-subexpressions (regexp replacements)
  "REPLACEMENTS need to be in reverse order if passed from lisp!"
  ;; Read the correct number of subexpressions
  (interactive
   (let* ((re (read-from-minibuffer "Query replace subexps: "))
          (num-subexps (reb-count-subexps re))
          (replacement-list nil)
          (replacements (dotimes (rep num-subexps)
                          (setq replacement-list
                                (cons
                                 (read-from-minibuffer
                                  (format "Replace subexpression %s with: " rep))
                                 replacement-list)))))
     (list re replacement-list)))
  ;; Search
  (let ((len (length replacements)))
    (while (search-forward-regexp regexp nil t)
      (replace-highlight (match-beginning 0) (match-end 0)
                         (point-min) (point-max) regexp
                         t case-fold-search)
      ;; Query
      (when (save-match-data (y-or-n-p "Replace this occurrence? "))
        ;; Make all the replacements
        (dotimes (i len)
          (replace-match (nth i replacements) nil nil nil (- len i)))))
    (replace-dehighlight)))


;; Test it out below
(query-replace-subexpressions
 "var .* = [a-zA-Z_]+\\s-*(\\(\\s-*\\).*?\\(\\s-*\\))"
 '("" ""))

var foo1 = blah(properties, property_id    );

var foo2 = blah (properties, property_id );

var foo3 = blah( properties, property_id      );
于 2012-07-01T19:48:41.980 に答える
1

私はそれquery-replace-regexpをgithubにフックしました

リンクが腐った場合の貼り付けは次のとおりです。

;; -*- lexical-binding: t -*-

(provide inverted-replace)

(require 're-builder)
(require 'parallel-replace)

(defun inverted-replace-generate-replacement (from to)
  "invert result of current match (match-string 0)"
  (let ((string (match-string 0))
        (count (reb-count-subexps from))
        (replacements (parallel-replace-read-list to)))
    (save-match-data
      (string-match from string)
      (dotimes (i count)
        (setq string (replace-match (nth i replacements) nil nil string (- count i)))))
    string))

(defun inverted-replace-regexp (from to)
  (interactive (destructuring-bind (from to _)
                   (query-replace-read-args "inverted-replace-regexp: " t)
                 (list from to)))
  (query-replace-regexp from
                        (quote (replace-eval-replacement
                                replace-quote
                                (inverted-replace-generate-replacement from to)))
                        nil (and (and transient-mark-mode mark-active)
                               (region-beginning))
                        (and (and transient-mark-mode mark-active) (region-end))))
于 2012-07-02T16:49:37.953 に答える