Erlang 의 정규 표현 식 모듈 re

6912 단어 erlangre 모듈
re 모듈 에는 조작 문자열 이나 바이트 문자열 의 함수 가 포함 되 어 있 습 니 다.
다음은 re 모듈 의 예 시 를 정규 표현 식 으로 소개 합 니 다.
1. 정규 표현 식 이 일치 하여 실 행 됩 니 다. 다음은 Erlang 문서 함수 원형 을 발췌 합 니 다.
run(Subject, RE) -> {match, Captured} | nomatch
Types:
Subject = iodata() | unicode:charlist()
RE = mp() | iodata()
Captured = [CaptureData]
CaptureData = {integer(), integer()}
The same as run(Subject,RE,[]).
run(Subject, RE, Options) ->
       {match, Captured} | match | nomatch | {error, ErrType}
Types:
Subject = iodata() | unicode:charlist()
RE = mp() | iodata() | unicode:charlist()
Options = [Option]
Option = anchored
       | global
       | notbol
       | noteol
       | notempty
       | notempty_atstart
       | report_errors
       | {offset, integer() >= 0}
       | {match_limit, integer() >= 0}
       | {match_limit_recursion, integer() >= 0}
       | {newline, NLSpec :: nl_spec()}
       | bsr_anycrlf
       | bsr_unicode
       | {capture, ValueSpec}
       | {capture, ValueSpec, Type}
       | CompileOpt
Type = index | list | binary
ValueSpec = all
          | all_but_first
          | all_names
          | first
          | none
          | ValueList
ValueList = [ValueID]
ValueID = integer() | string() | atom()
CompileOpt = compile_option()
See compile/2 above.
Captured = [CaptureData] | [[CaptureData]]
CaptureData = {integer(), integer()}
            | ListConversionData
            | binary()
ListConversionData = string()
                   | {error, string(), binary()}
                   | {incomplete, string(), binary()}
ErrType = match_limit
        | match_limit_recursion
        | {compile, CompileErr}
CompileErr =
    {ErrString :: string(), Position :: integer() >= 0}

RE 는 세 가지 유형 이 있 습 니 다. 하 나 는 컴 파일 된 regular expression (투명 한 데이터 형식, {re pattern, term (), term (), term (), term ()} 입 니 다. re: copile 로 얻 을 수 있 습 니 다).하 나 는 list;하 나 는 바 이 너 리.
예 1: 셸 에서 실행
1> {ok, MP} = re:compile("<.*?>",[caseless]).
{ok,{re_pattern,0,0,
                <<69,82,67,80,53,0,0,0,1,0,0,0,7,0,0,0,0,0,0,0,60,0,62,
                  ...>>}}
2> re:run("<HTML><body>hello world</body></html>", MP, []).
{match,[{0,6}]}

결과 {match, [{0, 6}} 을 되 돌려 줍 니 다. 첫 번 째 위치, 6 바이트 길이 ("< HTML >") 를 표시 합 니 다.
예 2: 컴 파일 된 regular expression 을 사용 하지 않 고 문자열 목록 을 정규 표현 식 으로 사용 할 수도 있 습 니 다.
7> re:run("<HTML><body>hello world</body></html>", "<.*?>", [{capture,first,list}]).
{match,["<HTML>"]}

이 예 는 일치 하 는 위치 와 길 이 를 되 돌려 주 는 것 이 아니 라 일치 하 는 문자열 입 니 다.이 옵션 은 {capture,..., list} 을 통 해 지정 합 니 다.
예 3: 모든 일치 하 는 문자열 을 되 돌려 줍 니 다.
re:run("<HTML><body>hello world</body></html>", "<.*?>", [{capture,first,list},global]).
{match,[["<HTML>"],["<body>"],["</body>"],["</html>"]]}

돌아 오 는 일치 하 는 문자열 결과 에 새 겨 진 목록 이 하나 더 있 음 을 주의 하 십시오 ([])
예 4: 탐욕 모델 과 비 탐욕 모델 비교
9> re:run("<HTML><body>hello world</body></html>", "<.*>", [{capture,first,list},global]). 
{match,[["<HTML><body>hello world</body></html>"]]}
10> 
10> 
10> re:run("<HTML><body>hello world</body></html>", "<.*>",
           [{capture,first,list},global,ungreedy]).
{match,[["<HTML>"],["<body>"],["</body>"],["</html>"]]}

탐욕 모드 는 일치 하 는 상황 에서 가능 한 한 길 게 일치 하 는 것 이다.탐욕 이 아 닌 패턴 은 반대 다.
예 5: 그룹 매 칭
11> Data = "io:format(\"hello ~p~n\",[world])".                                 
"io:format(\"hello ~p~n\",[world])"
12> 
12> RE = "(.*):(.*)\s*\\((.*)\s*\\)\s*$".
"(.*):(.*) *\\((.*) *\\) *$"
13> 
13> {match, [M,F,A] } = re:run(Data, RE, [{capture, [1,2,3], list}, ungreedy]).
{match,["io","format","\"hello ~p~n\",[world]"]}
14> 
14> M.
"io"
15> F.
"format"
16> A.
"\"hello ~p~n\",[world]"

   정규 표현 식 은 작은 괄호 로 표 시 된 그룹 을 사용 합 니 다.조별 번 호 는 왼쪽 에서 오른쪽으로 1, 2, 3...
2. 문자열 바 꾸 기
    replace 원형 은 다음 과 같 습 니 다.
replace(Subject, RE, Replacement) -> iodata() | unicode:charlist()
Types:
Subject = iodata() | unicode:charlist()
RE = mp() | iodata()
Replacement = iodata() | unicode:charlist()
The same as replace(Subject,RE,Replacement,[]).
replace(Subject, RE, Replacement, Options) ->
           iodata() | unicode:charlist()
Types:
Subject = iodata() | unicode:charlist()
RE = mp() | iodata() | unicode:charlist()
Replacement = iodata() | unicode:charlist()
Options = [Option]
Option = anchored
       | global
       | notbol
       | noteol
       | notempty
       | notempty_atstart
       | {offset, integer() >= 0}
       | {newline, NLSpec}
       | bsr_anycrlf
       | {match_limit, integer() >= 0}
       | {match_limit_recursion, integer() >= 0}
       | bsr_unicode
       | {return, ReturnType}
       | CompileOpt
ReturnType = iodata | list | binary
CompileOpt = compile_option()
NLSpec = cr | crlf | lf | anycrlf | any

예 6: 첫 번 째 일치 하 는 문자열 바 꾸 기
17> re:replace("hello", "l", "k", [{return, list}]).
"heklo"

예 6: 일치 하 는 모든 문자열 바 꾸 기
18> re:replace("hello", "l", "k", [{return, list},global]).
"hekko"

3. 문자열 분할
    split 원형 은 다음 과 같 습 니 다:
split(Subject, RE) -> SplitList

Types:
Subject = iodata() | unicode:charlist()
RE = mp() | iodata()
SplitList = [iodata() | unicode:charlist()]

The same as split(Subject,RE,[]).

split(Subject, RE, Options) -> SplitList

Types:
Subject = iodata() | unicode:charlist()
RE = mp() | iodata() | unicode:charlist()
Options = [Option]
Option = anchored
       | notbol
       | noteol
       | notempty
       | notempty_atstart
       | {offset, integer() >= 0}
       | {newline, nl_spec()}
       | {match_limit, integer() >= 0}
       | {match_limit_recursion, integer() >= 0}
       | bsr_anycrlf
       | bsr_unicode
       | {return, ReturnType}
       | {parts, NumParts}
       | group
       | trim
       | CompileOpt
NumParts = integer() >= 0 | infinity
ReturnType = iodata | list | binary
CompileOpt = compile_option()
See compile/2 above.
SplitList = [RetData] | [GroupedRetData]
GroupedRetData = [RetData]
RetData = iodata() | unicode:charlist() | binary() | list()

예:
19> re:split("hello,world", ",", [{return, list}]).
["hello","world"]
중국 전통 숫자, 정규 표현 식...
docker 용기간 통신

좋은 웹페이지 즐겨찾기

개발자 우수 사이트 수집

개발자가 알아야 할 필수 사이트 100선 추천 우리는 당신을 위해 100개의 자주 사용하는 개발자 학습 사이트를 정리했습니다
best100-homepage