=== FRAME ===
above : 바깥 테두리를(이하 생략) 위쪽만 표시
below : 아래쪽만 표시
border or box : 모두 표시
lhs : 왼쪽만 표시
rhs : 오른쪽만 표시
hsides : 세로선 ( 왼/오른쪽 ) 만 표시
vsides : 가로선 ( 위/아래 ) 만 표시
void : 테두리 표시 안함
ex )
<table border="1" frame="below" cellpadding="0" cellspacing="0">
=== RULES ===
all : 안쪽 테두리를 ( 이하 생략 ) 모두 표시
cols : 칸 구분선만 표시
rows : 줄 구분선만 표시
groups : 그룹요소들의 안쪽 테두리만 표시
none : 표시 안함
<table border="1" rules="all" cellpadding="0" cellspacing="0">
Oracle 10g Simplified Shared Server Configuration
In Oracle 10g, you no longer need to set as many initialization parameters for shared server environments. In fact, you only need to set one parameter if you are using TCP/IP as your communication protocol, and the rest of the settings are now managed internally.
Shared Server Initialization Parameters
The following initialization parameters in Oracle 10g control shared server operation:
shared_servers – This parameter specifies the initial number of shared servers to start and the minimum number of shared servers to keep. This is the only required parameter for using shared servers. Setting this to a non-zero value automatically specifies shared server.
max_shared_servers – This parameter specifies the maximum number of shared servers that can run simultaneously. Once shared server is initialized, the Oracle system will increase the number of shared servers up to this value as needed.
shared_server_sessions -- This parameter specifies the total number of shared server user sessions that can run simultaneously. Setting this parameter enables you to reserve user sessions for dedicated servers. For example, if the sessions parameter is set at 1000 and you set shared_server_sessions to 900, then 100 dedicated sessions are available, even if all 900 shared sessions are in use.
dispatchers – This parameter configures dispatcher processes in the shared server architecture. One dispatcher is always configured by default for the TCP/IP protocol, even if the parameter is not explicitly specified.
max_dispatchers – This parameter specifies the maximum number of dispatcher processes that can run simultaneously. According to the Oracle 10g manuals, this parameter can be ignored for now. It will only be useful in a future release when the number of dispatchers is auto-tuned, according to the number of concurrent connections.
circuits – This parameter specifies the total number of virtual circuits that are available for inbound and outbound network sessions.
Even though there are six initialization parameters, shared server is enabled by setting one parameter and is turned on if the shared_servers initialization parameter is set to a value greater than 0. This is all that is required. The other shared server initialization parameters do not need to be set. Because the shared server parameter requires at least one dispatcher to work, a dispatcher is brought up automatically even when no dispatcher has been configured.
Using SQL*Plus or OEM, the shared server features can be started dynamically by setting the shared_servers parameter to a nonzero value
The switch from dedicated server to shared server is easy. You begin by editing the init.ora file for your instance. You will need to either add in a line for dispatchers, or edit the existing line (When creating a database with DBCA on Windows, Oracle adds in a line even if you don't request dispatchers. So, be aware of the fact that you may just be changing that line).
At minimum, you will need:
dispatchers="(protocol=tcp)"
A more complete configuration would be:
dispatchers="(protocol=tcp)(dispatchers=2)(service=mydatabase)"
The (dispatchers=2) that you see tells oracle to spawn 2 dispatchers at startup.
Configuring dispatchers can get more elaborate. Unless you have experience and documentation for setting up a more advanced configuration, it is probably better to allow Oracle to give you default values for everything else. A complete list of possible dispatcher parameters is here:
이올린에 북마크하기
dispatch_clause::= (PROTOCOL = protocol) | (ADDRESS = address) | (DESCRIPTION = description ) [options_clause] options_clause::= (DISPATCHERS = integer | SESSIONS = integer | CONNECTIONS = integer | TICKS = seconds | POOL = {1 | ON | YES | TRUE | BOTH | ({IN | OUT} = ticks) | 0 | OFF | NO | FALSE | ticks} | MULTIPLEX = {1 | ON | YES | TRUE | 0 | OFF | NO | FALSE | BOTH | IN | OUT} | LISTENER = tnsname | SERVICE = service | INDEX = integer ) There are some other parameters you will likely want to set as long as you are working on dispatchers. Here is an example: ########################################### # DISPATCHERS ########################################### dispatchers="(protocol=tcp)(dispatchers=2)(service=test)" ## shared servers on startup shared_servers=2 ## maximum shared server sessions shared_server_sessions=200 ## Maximum Shared Servers max_shared_servers=20 ## Maximum Dispatchers max_dispatchers=20Once you have changed your init.ora file and bounced your database, how can you tell if connections are going through dispatchers? There are a number of dynamic performance views that can tell you this, for example v$session, v$dispatcher, v$queue. To keep things easy, I just create my own view that gives me the data I like to see:
CREATE OR REPLACE FORCE VIEW SYSTEM.CURRENT_CONNECTIONS (SID, SERIAL#, USERNAME, OSUSER, STATUS, "SCNDS NOT ACTIVE", DISPATCHER) AS SELECT /* ©2004 by Edward Stoever, edward@database-expert.com */ s.SID, s.serial#, s.username, s.osuser, s.status, DECODE (s.username, NULL, 0, s.last_call_et) "SCNDS NOT ACTIVE", NVL (d.NAME, 'none') "DISPATCHER" FROM v$session s, v$dispatcher d WHERE s.paddr = d.paddr(+) ORDER BY status ASC, last_call_et ASC; CREATE PUBLIC SYNONYM CURRENT_CONNECTIONS FOR SYSTEM.CURRENT_CONNECTIONS; Sample output: select * from system.current_connections; SID SERIAL# USERNAME OSUSER STATUS SCNDS NOT ACTIVE DISPAT ------ ------- ------------ ------------ -------- ---------------- ------ 15 167 SYSTEM STOEVER ACTIVE 0 none 11 10 GENERAL GURJOBS_TEST ACTIVE 12535 none 1 1 @ ORACLE ACTIVE 0 none 2 1 @ ORACLE ACTIVE 0 none 3 1 @ ORACLE ACTIVE 0 none 4 1 @ ORACLE ACTIVE 0 none 5 1 @ ORACLE ACTIVE 0 none 6 1 @ ORACLE ACTIVE 0 none 7 1 @ ORACLE ACTIVE 0 none 8 1 @ ORACLE ACTIVE 0 none 18 176 WTAILOR jbautista INACTIVE 12 D000 16 191 WTAILOR jbautista INACTIVE 132 D001 10 212 WTAILOR jbautista INACTIVE 134 D001 13 119 WEB_USER SYSTEM INACTIVE 314 D000 14 20 SYSTEM vlugo INACTIVE 721 D001Now you can see who is connecting and how, either via a dispatcher or via a dedicated connection.
### SHARED CONNECTION TO TEST DATABASE TEST_SHARED = (DESCRIPTION = (ADDRESS_LIST = (ADDRESS = (PROTOCOL = TCP)(HOST = alpha2)(PORT = 1521)) ) (CONNECT_DATA = (SERVER = SHARED) (SERVICE_NAME = test) ) ) ### DEDICATED CONNECTION TO TEST DATABASE TEST_DEDICATED = (DESCRIPTION = (ADDRESS_LIST = (ADDRESS = (PROTOCOL = TCP)(HOST = alpha2)(PORT = 1521)) ) (CONNECT_DATA = (SERVER = DEDICATED) (SERVICE_NAME = test) ) )Now, to connect via a dispatcher, try this:
SQLPLUS scott/tiger@test_sharedto connect via a dedicated server process, try this:
SQLPLUS scott/tiger@test_dedicated[출처] [펌] from dedicated to shared server|작성자 새내기
File 클래스
File클래스에는 일반 파일을 생성하는 기능을 제외한 이미 존재하는 파일에 대한 제어나 특수한 파일인 디렉토리를 생성하는 기능이 지원된다. 파일이라는 객체와 관련된 동작에 대한 메서드들은 모두 이 클래스에서 지원된다.
import java.io.*;
import java.util.*;
public class FileInfo{
public static void main(String args[]){
File f=new File("D:/StudyII/Java/Example/File",args[0]);
if(f.exists()) //파일이 존재하면
System.out.println("Existed!!");
else
System.out.println("Not Found!!");
}
}
◆ 결과
c:\Test>jva FileInfo 파일명
있으면 ?? 없으면 ??
>>> File클래스 관련 예제 (디렉토리 안의 파일 열기)<<<
import java.io.*;
import java.util.*;
public class FileInfo2{
public static void main(String args[]){
File f=new File(args[0]);
if(f.isDirectory()){
String list[]=f.list();
for(int i=0; i<list.length; i++)
System.out.println(list[i]);
}else
System.out.println("Not a Directory!!");
}
}
◆ 결과
c:\Test>java FileInfo2 Test
Test가 디렉토리라면 디렉토리 안의 파일 열거
Test가 디렉토리가 아니면 Not a Directory
>>> File클래스 관련 문제 (마지막 수정된 날짜 표시하기)<<<
import java.io.*;
import java.util.*;
public class FileTest1{
public static void main(String args[]){
File f=new File("D:/StudyII/Java/Example/File/Test");
File[] contents=f.listFiles();
System.out.println("File디렉토리에 들어있는 "+contents.length+"개의 항목");
for(int i=0; i<contents.length; i++){
System.out.println(contents[i]+"는"+new Date(contents[i].lastModified())+"에 수정된 "+
(contents[i].isDirectory()?"디렉토리이다.":"파일이다.")
);
}
}
}
>>> File클래스 관련 문제 <<<
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
◆ Lab1 : 구구단을 출력할 파일명과 단을 각각 인수로 입력받아 File클래스를 이용하여 파일을
생성하고 새로운 파일에 구구단이 아래와 같이 출력되는 소스를 작성한다.
---------------------------------------------------------------------------------------------------------
c:\Test>java FileTest2 2 2Dan.txtimport java.util.*;
public class FileTest2{
public static void main(String args[]){
String dan=args[0];
try{
FileWriter bw=new FileWriter(args[1]);
for(int i=1; i<10; i++){
bw.write(dan+"*"+i+"="+(Integer.parseInt(dan)*i)+"\n");
}
bw.close();
}catch(IOException e){
System.out.println(e);
}
}
}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
◆ Lab2 : 디렉토리명을 사용자로부터 입력받아 아래처럼 디렉토리를 생성하는 소스를 작성한다.
--------------------------------------------------------------------------------------------------------------------
import java.io.*;
class Test{
public static void main(String args[]) throws IOException{
System.out.println("디렉토리 생성하기!");
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String directoryName=br.readLine();
File f=new File(directoryName);
if(f.mkdir()){
System.out.println("디렉토리 '"+directoryName+"' 생성됨!");
}else{
System.out.println("디렉토리 '"+directoryName+"' 생성되지 않음!");
}
}
}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
◆ Lab3 : 아래와 같이 출력되도록 소스를 작성한다.
---------------------------------------------------------------------------------------------------------
c:\Test>java Testpublic class Test{
public static void main(String args[]){
System.out.println("파일경로구분자 ==> "+File.pathSeparator);
System.out.println("디렉토리구분자 ==> "+File.separator);
File[] root=File.listRoots();
for(File f:root){
System.out.println("루트 디렉토리 ==> "+f);
}
System.out.println("현재 디렉토리 ==> "+new File(".").getAbsolutePath());
}
}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
◆ Lab3 : 아래 실행결과처럼 Root File명(드라이버명)과 file명, 디렉토리명이 찍히도록 소스를 작성한다.
단, 디렉토리는 대괄호를 씌워서 구분짓는다. 모든 드라이버명 다 출력
---------------------------------------------------------------------------------------------------------
c:\Test>java ExListRootsimport java.io.*;
class ExListRoots{
public static void main(String args[]){
File[] rootFile=File.listRoots();
for(int i=0; i<rootFile.length; i++){
System.out.println(rootFile[i]);
if(rootFile[i].toString().startsWith("C:")){
File[] fileName=rootFile[i].listFiles();
for(int j=0; j<fileName.length; j++){
if(fileName[j].isFile())
System.out.println("\t"+fileName[j].getName());
else
System.out.println("\t["+fileName[j].getName()+"]");
}
}
}
}
}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
◆ Lab4 : 파일의 확장명이 java인것 파일만 출력되도록 소스를 작성한다.
---------------------------------------------------------------------------------------------------------
import java.io.*;━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
◆ Lab5 : 파일이름에 “Li”를 포함하는 파일만 출력되도록 소스를 작성한다.
---------------------------------------------------------------------------------------------------------
import java.io.*;
public class FileTest{
public static void main(String args[]) throws Exception{
File f=new File("c:\\");
String files[]=f.list();
for(int i=0; i<files.length; i++){
if(files[i].indexOf("Li") != -1) //indexOf()가 -1이면 찾는 문자열이 없음
System.out.println(files[i]);
}
}
}
파일의 이름을 필터링할 수 있는 기능을 가진 인터페이스
만약 어떤 디렉토리의 파일들의 목록을 읽어서 확장자가 .java로 끝나는 파일들만 검색하고 싶다면 다음과 같이 해주어야 한다.
FilenameFilter인터페이스를 구현하는 클래스를 만들고 accept()를 만든다.
File객체의 list()를 이용해서 원하는 디렉토리의 해당 파일 목록을 구한다.
>>> FilenameFilter인터페이스 관련 예제 <<<
import java.io.*;
class MyFilter implements FilenameFilter{
public boolean accept(File dir, String fileName){
return fileName.endsWith(".java");
}
}
public class FilterEx{
public static void main(String args[]){
FilterEx fe=new FilterEx();
fe.test();
}
public void test(){
File dir=new File("c:\Test");
MyFilter filter=new MyFilter();
File[] files=dir.listFiles(filter);
for(int i=0; i<files.length; i++)
System.out.println("File Name : "+files[i].getName());
}
}
◆ 결과
c:\Test>java FileterEx
File Name : TbarApplet.java
>>> FilenameFilter인터페이스 관련 예제 <<<
import java.io.*;
class MyFilter implements FilenameFilter{
private String keyword;
private String fileExt;
public MyFilter(String keyword, String fileExt){
this.keyword=keyword;
this.fileExt=fileExt;
}
public boolean accept(File dir, String fileName){
if(fileExt.equals("all"))
fileExt="\\w*";
return fileName.matches("\\w*"+keyword+"\\w*."+fileExt);
}
}
public class FilterEx{
public static void main(String args[]){
FilterEx fe=new FilterEx();
fe.test();
}
public void test(){
File dir=new File("c:\Test");
MyFilter filter=new MyFilter("Test","java");
File[] files=dir.listFiles(filter);
for(int i=0; i<files.length; i++)
System.out.println("File Name : "+files[i].getName());
}
}
◆ 결과
c:\Test>java FileterEx
File Name : ArrayTest.java
File Name : EventTest.java [출처] File 클래스 , FilenameFilter인터페이스|작성자 강현아빠
Tcpdump prints out a description of the contents of packets on a network interface that match the boolean expression. It can also be run with the -w flag, which causes it to save the packet data to a file for later analysis, and/or with the -r flag, which causes it to read from a saved packet file rather than to read packets from a network interface. In all cases, only packets that match expression will be processed by tcpdump.
Tcpdump will, if not run with the -c flag, continue capturing packets until it is interrupted by a SIGINT signal (generated, for example, by typing your interrupt character, typically control-C) or a SIGTERM signal (typically generated with the kill(1) command); if run with the -c flag, it will capture packets until it is interrupted by a SIGINT or SIGTERM signal or the specified number of packets have been processed.
When tcpdump finishes capturing packets, it will report counts of:
On platforms that support the SIGINFO signal, such as most BSDs (including Mac OS X) and Digital/Tru64 UNIX, it will report those counts when it receives a SIGINFO signal (generated, for example, by typing your ``status'' character, typically control-T, although on some platforms, such as Mac OS X, the ``status'' character is not set by default, so you must set it with stty(1) in order to use it) and will continue capturing packets.
Reading packets from a network interface may require that you have special privileges:
Reading a saved packet file doesn't require special privileges.
The expression consists of one or more primitives. Primitives usually consist of an id (name or number) preceded by one or more qualifiers. There are three different kinds of qualifier:
[`fddi' is actually an alias for `ether'; the parser treats them identically as meaning ``the data link level used on the specified network interface.'' FDDI headers contain Ethernet-like source and destination addresses, and often contain Ethernet-like packet types, so you can filter on these FDDI fields just as with the analogous Ethernet fields. FDDI headers also contain other fields, but you cannot name them explicitly in a filter expression.
Similarly, `tr' and `wlan' are aliases for `ether'; the previous paragraph's statements about FDDI headers also apply to Token Ring and 802.11 wireless LAN headers. For 802.11 headers, the destination address is the DA field and the source address is the SA field; the BSSID, RA, and TA fields aren't tested.]
In addition to the above, there are some special `primitive' keywords that don't follow the pattern: gateway, broadcast, less, greater and arithmetic expressions. All of these are described below.
More complex filter expressions are built up by using the words and, or and not to combine primitives. E.g., `host foo and not port ftp and not port ftp-data'. To save typing, identical qualifier lists can be omitted. E.g., `tcp dst port ftp or ftp-data or domain' is exactly the same as `tcp dst port ftp or tcp dst port ftp-data or tcp dst port domain'.
Allowable primitives are:
ip host hostwhich is equivalent to:
ether proto \ip and host hostIf host is a name with multiple IP addresses, each address will be checked for a match.
ether host ehost and not host hostwhich can be used with either names or numbers for host / ehost.) This syntax does not work in IPv6-enabled configuration at this moment.
tcp src port portwhich matches only tcp packets whose source port is port.
len <= length.
len >= length.
ip6 protochain 6matches any IPv6 packet with TCP protocol header in the protocol header chain. The packet may contain, for example, authentication header, routing header, or hop-by-hop option header, between IPv6 header and TCP header. The BPF code emitted by this primitive is complex and cannot be optimized by BPF optimizer code in tcpdump, so this can be somewhat slow.
ether proto pwhere p is one of the above protocols.
ether proto pwhere p is one of the above protocols. Note that tcpdump does not currently know how to parse these protocols.
vlan 100 && vlan 200filters on VLAN 200 encapsulated within VLAN 100, and
vlan && vlan 300 && ipfilters IPv4 protocols encapsulated in VLAN 300 encapsulated within any higher order VLAN.
mpls 100000 && mpls 1024filters packets with an outer label of 100000 and an inner label of 1024, and
mpls && mpls 1024 && host 192.9.200.1filters packets to or from 192.9.200.1 with an inner label of 1024 and any outer label.
pppoes && ipfilters IPv4 protocols encapsulated in PPPoE.
ip proto p or ip6 proto pwhere p is one of the above protocols.
iso proto pwhere p is one of the above protocols.
proto [ expr : size ]Proto is one of ether, fddi, tr, wlan, ppp, slip, link, ip, arp, rarp, tcp, udp, icmp, ip6 or radio, and indicates the protocol layer for the index operation. (ether, fddi, wlan, tr, ppp, slip and link all refer to the link layer. radio refers to the "radio header" added to some 802.11 captures.) Note that tcp, udp and other upper-layer protocol types only apply to IPv4, not IPv6 (this will be fixed in the future). The byte offset, relative to the indicated protocol layer, is given by expr. Size is optional and indicates the number of bytes in the field of interest; it can be either one, two, or four, and defaults to one. The length operator, indicated by the keyword len, gives the length of the packet.
For example, `ether[0] & 1 != 0' catches all multicast traffic. The expression `ip[0] & 0xf != 5' catches all IPv4 packets with options. The expression `ip[6:2] & 0x1fff = 0' catches only unfragmented IPv4 datagrams and frag zero of fragmented IPv4 datagrams. This check is implicitly applied to the tcp and udp index operations. For instance, tcp[0] always means the first byte of the TCP header, and never means the first byte of an intervening fragment.
Some offsets and field values may be expressed as names rather than as numeric values. The following protocol header field offsets are available: icmptype (ICMP type field), icmpcode (ICMP code field), and tcpflags (TCP flags field).
The following ICMP type field values are available: icmp-echoreply, icmp-unreach, icmp-sourcequench, icmp-redirect, icmp-echo, icmp-routeradvert, icmp-routersolicit, icmp-timxceed, icmp-paramprob, icmp-tstamp, icmp-tstampreply, icmp-ireq, icmp-ireqreply, icmp-maskreq, icmp-maskreply.
The following TCP flags field values are available: tcp-fin, tcp-syn, tcp-rst, tcp-push, tcp-ack, tcp-urg.
Primitives may be combined using:
Negation has highest precedence. Alternation and concatenation have equal precedence and associate left to right. Note that explicit and tokens, not juxtaposition, are now required for concatenation.
If an identifier is given without a keyword, the most recent keyword is assumed. For example,
not host vs and aceis short for
not host vs and host acewhich should not be confused with
not ( host vs or ace )
Expression arguments can be passed to tcpdump as either a single argument or as multiple arguments, whichever is more convenient. Generally, if the expression contains Shell metacharacters, it is easier to pass it as a single, quoted argument. Multiple arguments are concatenated with spaces before being parsed.
To print all packets arriving at or departing from sundown:
tcpdump host sundown
To print traffic between helios and either hot or ace:
tcpdump host helios and \( hot or ace \)
To print all IP packets between ace and any host except helios:
tcpdump ip host ace and not helios
To print all traffic between local hosts and hosts at Berkeley:
tcpdump net ucb-ether
To print all ftp traffic through internet gateway snup: (note that the expression is quoted to prevent the shell from (mis-)interpreting the parentheses):
tcpdump 'gateway snup and (port ftp or ftp-data)'
To print traffic neither sourced from nor destined for local hosts (if you gateway to one other net, this stuff should never make it onto your local net).
tcpdump ip and not net localnet
To print the start and end packets (the SYN and FIN packets) of each TCP conversation that involves a non-local host.
tcpdump 'tcp[tcpflags] & (tcp-syn|tcp-fin) != 0 and not src and dst net localnet'
To print all IPv4 HTTP packets to and from port 80, i.e. print only packets that contain data, not, for example, SYN and FIN packets and ACK-only packets. (IPv6 is left as an exercise for the reader.)
tcpdump 'tcp port 80 and (((ip[2:2] - ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0)'
To print IP packets longer than 576 bytes sent through gateway snup:
tcpdump 'gateway snup and ip[2:2] > 576'
To print IP broadcast or multicast packets that were not sent via Ethernet broadcast or multicast:
tcpdump 'ether[0] & 1 = 0 and ip[16] >= 224'
To print all ICMP packets that are not echo requests/replies (i.e., not ping packets):
tcpdump 'icmp[icmptype] != icmp-echo and icmp[icmptype] != icmp-echoreply'
The output of tcpdump is protocol dependent. The following gives a brief description and examples of most of the formats.
Link Level Headers
If the '-e' option is given, the link level header is printed out. On Ethernets, the source and destination addresses, protocol, and packet length are printed.
On FDDI networks, the '-e' option causes tcpdump to print the `frame control' field, the source and destination addresses, and the packet length. (The `frame control' field governs the interpretation of the rest of the packet. Normal packets (such as those containing IP datagrams) are `async' packets, with a priority value between 0 and 7; for example, `async4'. Such packets are assumed to contain an 802.2 Logical Link Control (LLC) packet; the LLC header is printed if it is not an ISO datagram or a so-called SNAP packet.
On Token Ring networks, the '-e' option causes tcpdump to print the `access control' and `frame control' fields, the source and destination addresses, and the packet length. As on FDDI networks, packets are assumed to contain an LLC packet. Regardless of whether the '-e' option is specified or not, the source routing information is printed for source-routed packets.
On 802.11 networks, the '-e' option causes tcpdump to print the `frame control' fields, all of the addresses in the 802.11 header, and the packet length. As on FDDI networks, packets are assumed to contain an LLC packet.
(N.B.: The following description assumes familiarity with the SLIP compression algorithm described in RFC-1144.)
On SLIP links, a direction indicator (``I'' for inbound, ``O'' for outbound), packet type, and compression information are printed out. The packet type is printed first. The three types are ip, utcp, and ctcp. No further link information is printed for ip packets. For TCP packets, the connection identifier is printed following the type. If the packet is compressed, its encoded header is printed out. The special cases are printed out as *S+n and *SA+n, where n is the amount by which the sequence number (or sequence number and ack) has changed. If it is not a special case, zero or more changes are printed. A change is indicated by U (urgent pointer), W (window), A (ack), S (sequence number), and I (packet ID), followed by a delta (+n or -n), or a new value (=n). Finally, the amount of data in the packet and compressed header length are printed.
For example, the following line shows an outbound compressed TCP packet, with an implicit connection identifier; the ack has changed by 6, the sequence number by 49, and the packet ID by 6; there are 3 bytes of data and 6 bytes of compressed header:
O ctcp * A+6 S+49 I+6 3 (6)
ARP/RARP Packets
Arp/rarp output shows the type of request and its arguments. The format is intended to be self explanatory. Here is a short sample taken from the start of an `rlogin' from host rtsg to host csam:
arp who-has csam tell rtsg arp reply csam is-at CSAM
This would look less redundant if we had done tcpdump -n:
arp who-has 128.3.254.6 tell 128.3.254.68 arp reply 128.3.254.6 is-at 02:07:01:00:01:c4
If we had done tcpdump -e, the fact that the first packet is broadcast and the second is point-to-point would be visible:
RTSG Broadcast 0806 64: arp who-has csam tell rtsg CSAM RTSG 0806 64: arp reply csam is-at CSAM
TCP Packets
(N.B.:The following description assumes familiarity with the TCP protocol described in RFC-793. If you are not familiar with the protocol, neither this description nor tcpdump will be of much use to you.)
The general format of a tcp protocol line is:
src > dst: flags data-seqno ack window urgent options
Src, dst and flags are always present. The other fields depend on the contents of the packet's tcp protocol header and are output only if appropriate.
Here is the opening portion of an rlogin from host rtsg to host csam.
rtsg.1023 > csam.login: S 768512:768512(0) win 4096 <mss 1024> csam.login > rtsg.1023: S 947648:947648(0) ack 768513 win 4096 <mss 1024> rtsg.1023 > csam.login: . ack 1 win 4096 rtsg.1023 > csam.login: P 1:2(1) ack 1 win 4096 csam.login > rtsg.1023: . ack 2 win 4096 rtsg.1023 > csam.login: P 2:21(19) ack 1 win 4096 csam.login > rtsg.1023: P 1:2(1) ack 21 win 4077 csam.login > rtsg.1023: P 2:3(1) ack 21 win 4077 urg 1 csam.login > rtsg.1023: P 3:4(1) ack 21 win 4077 urg 1
Csam replies with a similar packet except it includes a piggy-backed ack for rtsg's SYN. Rtsg then acks csam's SYN. The `.' means no flags were set. The packet contained no data so there is no data sequence number. Note that the ack sequence number is a small integer (1). The first time tcpdump sees a tcp `conversation', it prints the sequence number from the packet. On subsequent packets of the conversation, the difference between the current packet's sequence number and this initial sequence number is printed. This means that sequence numbers after the first can be interpreted as relative byte positions in the conversation's data stream (with the first data byte each direction being `1'). `-S' will override this feature, causing the original sequence numbers to be output.
On the 6th line, rtsg sends csam 19 bytes of data (bytes 2 through 20 in the rtsg -> csam side of the conversation). The PUSH flag is set in the packet. On the 7th line, csam says it's received data sent by rtsg up to but not including byte 21. Most of this data is apparently sitting in the socket buffer since csam's receive window has gotten 19 bytes smaller. Csam also sends one byte of data to rtsg in this packet. On the 8th and 9th lines, csam sends two bytes of urgent, pushed data to rtsg.
If the snapshot was small enough that tcpdump didn't capture the full TCP header, it interprets as much of the header as it can and then reports ``[|tcp]'' to indicate the remainder could not be interpreted. If the header contains a bogus option (one with a length that's either too small or beyond the end of the header), tcpdump reports it as ``[bad opt]'' and does not interpret any further options (since it's impossible to tell where they start). If the header length indicates options are present but the IP datagram length is not long enough for the options to actually be there, tcpdump reports it as ``[bad hdr length]''.
Capturing TCP packets with particular flag combinations (SYN-ACK, URG-ACK, etc.)
There are 8 bits in the control bits section of the TCP header:
Let's assume that we want to watch packets used in establishing a TCP connection. Recall that TCP uses a 3-way handshake protocol when it initializes a new connection; the connection sequence with regard to the TCP control bits is
Now we're interested in capturing packets that have only the SYN bit set (Step 1). Note that we don't want packets from step 2 (SYN-ACK), just a plain initial SYN. What we need is a correct filter expression for tcpdump.
Recall the structure of a TCP header without options:
0 15 31 ----------------------------------------------------------------- | source port | destination port | ----------------------------------------------------------------- | sequence number | ----------------------------------------------------------------- | acknowledgment number | ----------------------------------------------------------------- | HL | rsvd |C|E|U|A|P|R|S|F| window size | ----------------------------------------------------------------- | TCP checksum | urgent pointer | -----------------------------------------------------------------
A TCP header usually holds 20 octets of data, unless options are present. The first line of the graph contains octets 0 - 3, the second line shows octets 4 - 7 etc.
Starting to count with 0, the relevant TCP control bits are contained in octet 13:
0 7| 15| 23| 31 ----------------|---------------|---------------|---------------- | HL | rsvd |C|E|U|A|P|R|S|F| window size | ----------------|---------------|---------------|---------------- | | 13th octet | | |
Let's have a closer look at octet no. 13:
이올린에 추천하기 | |
|---------------|
|C|E|U|A|P|R|S|F|
|---------------|
|7 5 3 0|
These are the TCP control bits we are interested in. We have numbered the bits in this octet from 0 to 7, right to left, so the PSH bit is bit number 3, while the URG bit is number 5.
Recall that we want to capture packets with only SYN set. Let's see what happens to octet 13 if a TCP datagram arrives with the SYN bit set in its header:
|C|E|U|A|P|R|S|F|
|---------------|
|0 0 0 0 0 0 1 0|
|---------------|
|7 6 5 4 3 2 1 0|
Looking at the control bits section we see that only bit number 1 (SYN) is set.
Assuming that octet number 13 is an 8-bit unsigned integer in network byte order, the binary value of this octet is
and its decimal representation is
7 6 5 4 3 2 1 0 0*2 + 0*2 + 0*2 + 0*2 + 0*2 + 0*2 + 1*2 + 0*2 = 2
We're almost done, because now we know that if only SYN is set, the value of the 13th octet in the TCP header, when interpreted as a 8-bit unsigned integer in network byte order, must be exactly 2.
This relationship can be expressed as
We can use this expression as the filter for tcpdump in order to watch packets which have only SYN set:
The expression says "let the 13th octet of a TCP datagram have the decimal value 2", which is exactly what we want.
Now, let's assume that we need to capture SYN packets, but we don't care if ACK or any other TCP control bit is set at the same time. Let's see what happens to octet 13 when a TCP datagram with SYN-ACK set arrives:
|C|E|U|A|P|R|S|F|
|---------------|
|0 0 0 1 0 0 1 0|
|---------------|
|7 6 5 4 3 2 1 0|
Now bits 1 and 4 are set in the 13th octet. The binary value of octet 13 is
which translates to decimal
7 6 5 4 3 2 1 0 0*2 + 0*2 + 0*2 + 1*2 + 0*2 + 0*2 + 1*2 + 0*2 = 18
Now we can't just use 'tcp[13] == 18' in the tcpdump filter expression, because that would select only those packets that have SYN-ACK set, but not those with only SYN set. Remember that we don't care if ACK or any other control bit is set as long as SYN is set.
In order to achieve our goal, we need to logically AND the binary value of octet 13 with some other value to preserve the SYN bit. We know that we want SYN to be set in any case, so we'll logically AND the value in the 13th octet with the binary value of a SYN:
00010010 SYN-ACK 00000010 SYN
AND 00000010 (we want SYN) AND 00000010 (we want SYN)
-------- --------
= 00000010 = 00000010
We see that this AND operation delivers the same result regardless whether ACK or another TCP control bit is set. The decimal representation of the AND value as well as the result of this operation is 2 (binary 00000010), so we know that for packets with SYN set the following relation must hold true:
This points us to the tcpdump filter expression
Note that you should use single quotes or a backslash in the expression to hide the AND ('&') special character from the shell.
UDP Packets
UDP format is illustrated by this rwho packet:
actinide.who > broadcast.who: udp 84
Some UDP services are recognized (from the source or destination port number) and the higher level protocol information printed. In particular, Domain Name service requests (RFC-1034/1035) and Sun RPC calls (RFC-1050) to NFS.
UDP Name Server Requests
(N.B.:The following description assumes familiarity with the Domain Service protocol described in RFC-1035. If you are not familiar with the protocol, the following description will appear to be written in greek.)
Name server requests are formatted as
src > dst: id op? flags qtype qclass name (len) h2opolo.1538 > helios.domain: 3+ A? ucbvax.berkeley.edu. (37)
A few anomalies are checked and may result in extra fields enclosed in square brackets: If a query contains an answer, authority records or additional records section, ancount, nscount, or arcount are printed as `[na]', `[nn]' or `[nau]' where n is the appropriate count. If any of the response bits are set (AA, RA or rcode) or any of the `must be zero' bits are set in bytes two and three, `[b2&3=x]' is printed, where x is the hex value of header bytes two and three.
UDP Name Server Responses
Name server responses are formatted as
src > dst: id op rcode flags a/n/au type class data (len) helios.domain > h2opolo.1538: 3 3/3/7 A 128.32.137.3 (273) helios.domain > h2opolo.1537: 2 NXDomain* 0/1/0 (97)
In the second example, helios responds to query 2 with a response code of non-existent domain (NXDomain) with no answers, one name server and no authority records. The `*' indicates that the authoritative answer bit was set. Since there were no answers, no type, class or data were printed.
Other flag characters that might appear are `-' (recursion available, RA, not set) and `|' (truncated message, TC, set). If the `question' section doesn't contain exactly one entry, `[nq]' is printed.
Note that name server requests and responses tend to be large and the default snaplen of 68 bytes may not capture enough of the packet to print. Use the -s flag to increase the snaplen if you need to seriously investigate name server traffic. `-s 128' has worked well for me.
SMB/CIFS decoding
tcpdump now includes fairly extensive SMB/CIFS/NBT decoding for data on UDP/137, UDP/138 and TCP/139. Some primitive decoding of IPX and NetBEUI SMB data is also done.
By default a fairly minimal decode is done, with a much more detailed decode done if -v is used. Be warned that with -v a single SMB packet may take up a page or more, so only use -v if you really want all the gory details.
For information on SMB packet formats and what all te fields mean see www.cifs.org or the pub/samba/specs/ directory on your favorite samba.org mirror site. The SMB patches were written by Andrew Tridgell (tridge@samba.org).
NFS Requests and Replies
Sun NFS (Network File System) requests and replies are printed as:
src.xid > dst.nfs: len op args
src.nfs > dst.xid: reply stat len op results
sushi.6709 > wrl.nfs: 112 readlink fh 21,24/10.73165
wrl.nfs > sushi.6709: reply ok 40 readlink "../var"
sushi.201b > wrl.nfs:
144 lookup fh 9,74/4096.6878 "xcolors"
wrl.nfs > sushi.201b:
reply ok 128 lookup fh 9,74/4134.3150
In the third line, sushi asks wrl to lookup the name `xcolors' in directory file 9,74/4096.6878. Note that the data printed depends on the operation type. The format is intended to be self explanatory if read in conjunction with an NFS protocol spec.
If the -v (verbose) flag is given, additional information is printed. For example:
sushi.1372a > wrl.nfs:
148 read fh 21,11/12.195 8192 bytes @ 24576
wrl.nfs > sushi.1372a:
reply ok 1472 read REG 100664 ids 417/0 sz 29388
If the -v flag is given more than once, even more details are printed.
Note that NFS requests are very large and much of the detail won't be printed unless snaplen is increased. Try using `-s 192' to watch NFS traffic.
NFS reply packets do not explicitly identify the RPC operation. Instead, tcpdump keeps track of ``recent'' requests, and matches them to the replies using the transaction ID. If a reply does not closely follow the corresponding request, it might not be parsable.
AFS Requests and Replies
Transarc AFS (Andrew File System) requests and replies are printed as:
src.sport > dst.dport: rx packet-type
src.sport > dst.dport: rx packet-type service call call-name args
src.sport > dst.dport: rx packet-type service reply call-name args
elvis.7001 > pike.afsfs:
rx data fs call rename old fid 536876964/1/1 ".newsrc.new"
new fid 536876964/1/1 ".newsrc"
pike.afsfs > elvis.7001: rx data fs reply rename
In general, all AFS RPCs are decoded at least by RPC call name. Most AFS RPCs have at least some of the arguments decoded (generally only the `interesting' arguments, for some definition of interesting).
The format is intended to be self-describing, but it will probably not be useful to people who are not familiar with the workings of AFS and RX.
If the -v (verbose) flag is given twice, acknowledgement packets and additional header information is printed, such as the the RX call ID, call number, sequence number, serial number, and the RX packet flags.
If the -v flag is given twice, additional information is printed, such as the the RX call ID, serial number, and the RX packet flags. The MTU negotiation information is also printed from RX ack packets.
If the -v flag is given three times, the security index and service id are printed.
Error codes are printed for abort packets, with the exception of Ubik beacon packets (because abort packets are used to signify a yes vote for the Ubik protocol).
Note that AFS requests are very large and many of the arguments won't be printed unless snaplen is increased. Try using `-s 256' to watch AFS traffic.
AFS reply packets do not explicitly identify the RPC operation. Instead, tcpdump keeps track of ``recent'' requests, and matches them to the replies using the call number and service ID. If a reply does not closely follow the corresponding request, it might not be parsable.
KIP AppleTalk (DDP in UDP)
AppleTalk DDP packets encapsulated in UDP datagrams are de-encapsulated and dumped as DDP packets (i.e., all the UDP header information is discarded). The file /etc/atalk.names is used to translate AppleTalk net and node numbers to names. Lines in this file have the form
number name 1.254 ether 16.1 icsd-net 1.254.110 ace
AppleTalk addresses are printed in the form
net.host.port 144.1.209.2 > icsd-net.112.220 office.2 > icsd-net.112.220 jssmag.149.235 > icsd-net.2
NBP (name binding protocol) and ATP (AppleTalk transaction protocol) packets have their contents interpreted. Other protocols just dump the protocol name (or number if no name is registered for the protocol) and packet size.
NBP packets are formatted like the following examples:
icsd-net.112.220 > jssmag.2: nbp-lkup 190: "=:LaserWriter@*" jssmag.209.2 > icsd-net.112.220: nbp-reply 190: "RM1140:LaserWriter@*" 250 techpit.2 > icsd-net.112.220: nbp-reply 190: "techpit:LaserWriter@*" 186
ATP packet formatting is demonstrated by the following example:
jssmag.209.165 > helios.132: atp-req 12266<0-7> 0xae030001 helios.132 > jssmag.209.165: atp-resp 12266:0 (512) 0xae040000 helios.132 > jssmag.209.165: atp-resp 12266:1 (512) 0xae040000 helios.132 > jssmag.209.165: atp-resp 12266:2 (512) 0xae040000 helios.132 > jssmag.209.165: atp-resp 12266:3 (512) 0xae040000 helios.132 > jssmag.209.165: atp-resp 12266:4 (512) 0xae040000 helios.132 > jssmag.209.165: atp-resp 12266:5 (512) 0xae040000 helios.132 > jssmag.209.165: atp-resp 12266:6 (512) 0xae040000 helios.132 > jssmag.209.165: atp-resp*12266:7 (512) 0xae040000 jssmag.209.165 > helios.132: atp-req 12266<3,5> 0xae030001 helios.132 > jssmag.209.165: atp-resp 12266:3 (512) 0xae040000 helios.132 > jssmag.209.165: atp-resp 12266:5 (512) 0xae040000 jssmag.209.165 > helios.132: atp-rel 12266<0-7> 0xae030001 jssmag.209.133 > helios.132: atp-req* 12267<0-7> 0xae030002
Helios responds with 8 512-byte packets. The `:digit' following the transaction id gives the packet sequence number in the transaction and the number in parens is the amount of data in the packet, excluding the atp header. The `*' on packet 7 indicates that the EOM bit was set.
Jssmag.209 then requests that packets 3 & 5 be retransmitted. Helios resends them then jssmag.209 releases the transaction. Finally, jssmag.209 initiates the next request. The `*' on the request indicates that XO (`exactly once') was not set.
IP Fragmentation
Fragmented Internet datagrams are printed as
(frag id:size@offset+) (frag id:size@offset)
Id is the fragment id. Size is the fragment size (in bytes) excluding the IP header. Offset is this fragment's offset (in bytes) in the original datagram.
The fragment information is output for each fragment. The first fragment contains the higher level protocol header and the frag info is printed after the protocol info. Fragments after the first contain no higher level protocol header and the frag info is printed after the source and destination addresses. For example, here is part of an ftp from arizona.edu to lbl-rtsg.arpa over a CSNET connection that doesn't appear to handle 576 byte datagrams:
arizona.ftp-data > rtsg.1170: . 1024:1332(308) ack 1 win 4096 (frag 595a:328@0+) arizona > rtsg: (frag 595a:204@328) rtsg.1170 > arizona.ftp-data: . ack 1536 win 2560
A packet with the IP don't fragment flag is marked with a trailing (DF).
Timestamps
By default, all output lines are preceded by a timestamp. The timestamp is the current clock time in the form
hh:mm:ss.frac
Van Jacobson, Craig Leres and Steven McCanne, all of the Lawrence Berkeley National Laboratory, University of California, Berkeley, CA.
It is currently being maintained by tcpdump.org.
The current version is available via http:
The original distribution is available via anonymous ftp:
IPv6/IPsec support is added by WIDE/KAME project. This program uses Eric Young's SSLeay library, under specific configuration.
Please send source code contributions, etc. to:
NIT doesn't let you watch your own outbound traffic, BPF will. We recommend that you use the latter.
On Linux systems with 2.0[.x] kernels:
We recommend that you upgrade to a 2.2 or later kernel.
Some attempt should be made to reassemble IP fragments or, at least to compute the right length for the higher level protocol.
Name server inverse queries are not dumped correctly: the (empty) question section is printed rather than real query in the answer section. Some believe that inverse queries are themselves a bug and prefer to fix the program generating them rather than tcpdump.
A packet trace that crosses a daylight savings time change will give skewed time stamps (the time change is ignored).
Filter expressions on fields other than those in Token Ring headers will not correctly handle source-routed Token Ring packets.
Filter expressions on fields other than those in 802.11 headers will not correctly handle 802.11 data packets with both To DS and From DS set.
ip6 proto should chase header chain, but at this moment it does not. ip6 protochain is supplied for this behavior.
Arithmetic expression against transport layer headers, like tcp[0], does not work against IPv6 packets. It only looks at IPv4 packets.
이복연 [wegra@wegra.org]
자바스터디 네트워크 [http://javastudy.co.kr]
어플리케이션들을 만들다 보면 종종 단어 검색, 메일 주소 점검, XML 문서의 무결성 확인 등과 같은 복잡한 문자열 처리 기능이 필요한 경우가 있게 마련이다. 이런 때에 패턴 매칭(pattern matching)이 자주 사용된다. Perl과 sed, awk와 같은 언어들은 일치하는 텍스트를 검색하기 위해, 패턴을 정의하는 문자들과 정규표현식을 사용해 향상된 패턴 매칭 능력을 제공해 주고 있다. 자바에서 패턴 매칭을 사용하려면 StringTokenizer 클래스와 수많은 charAt, substring 메소드를 동원해야만 한다. 하지만 이런 방식은 종종 아주 복잡하고 지저분한 코드를 만들어내곤 한다.
하지만 모두 지금까지의 이야기일 뿐 Java 2 Platform, Standard Edition(J2SE)가 1.4로 넘어오면서 정규 표현식을 다룰 수 있는 java.util.regex라는 새로운 패키지가 추가되었다. 이제 자바에도 정규 표현식의 강력함을 맛볼 수 있는 메타 캐릭터들을 사용할 수 있게 되었다.
이번 글에서는 정규 표현식에 대해 간단히 설명하고, 아래의 과정에 따라 java.util.regex 패키지를 통해 정규 표현식을 활용하는 방법에 대해 자세히 설명하도록 하겠다.
l 단어 바꾸기
l 메일 주소 점검
l 파일에서 제어 문자 제거
l 파일 검색
(이 글의 예제들을 실행시켜보려면 J2SE 1.4 호환 컴파일러와 가상머신이 필요함)
정규 표현식 만들기
정규표현식이란 여러 문자열들의 공통적인 특성을 기술하는 문자들의 패턴이다. java.util.regex 패키지를 보면 입력 데이터로부터 패턴을 찾고 수정할 수 있는 다양한 방법들이 제공됨을 확인할 수 있을 것이다.
정규표현식의 가장 단순한 형태는 ‘Java’, ‘programming’과 같은 일반적인 문자열이다. 또한 메일 주소와 같이 특수한 포맷을 갖는 문자열을 검증 등도 가능하다.
정규 표현식에는 일반 문자들과 특수 문자들이 혼용되어 사용된다.
|
\$ |
^ |
. |
* |
|
+ |
? |
[‘ |
‘] |
|
\. |
|
|
|
‘\’로 시작하는 문자열을 제외한 모든 문자들은 보통 문자를 의미한다.
특수 문자들은 물론 고유한 기능을 갖고 있다. 예를 들어 ‘.’ 의 경우 라인 종결 문자를 제외한 어떤 문자와도 대응될 수 있다. 따라서 정규표현식 ‘s.n’ 은 ‘sun’, ‘son’ 등과 같이 ‘s’ 로 시작하고 ‘n’ 으로 끝나는 세 자로 된 문자열 어떤 것이든 될 수 있다.
이와 같이 우리는 정규표현식에서 제공되는 여러 특수 문자들을 통해 줄의 시작 단어를 찾거나, 특정 범위의 문자 찾기, 대소문자 구별 없이 찾기, 정확히 일치하는 단어 찾기 등의 작업을 쉽게 처리할 수 있다.
java.util.regex 패키지에서 제공하는 정규표현식은 Perl 언어에서의 정규표현식 사용법과 같기 때문에 Perl에 익숙한 사용자라면 같은 문법을 그대로 자바에도 적용할 수 있다. 만약 정규표현식에 익숙하지 않다면 아래 표가 많은 도움이 될 것이다.
|
Construct |
Matches |
|
Characters |
|
|
X |
The character x |
|
\\ |
The backslash character |
|
\0n |
The character with octal value 0n (0 <= n <= 7) |
|
\0nn |
The character with octal value 0nn (0 <= n <= 7) |
|
\0mnn |
The character with octal value 0mnn (0 <= m <= 3, 0 <= n <= 7) |
|
\xhh |
The character with hexadecimal value 0xhh |
|
\uhhhh |
The character with hexadecimal value 0xhhhh |
|
\t |
The tab character ('\u0009') |
|
\n |
The newline (line feed) character ('\u000A') |
|
\r |
The carriage-return character ('\u000D') |
|
\f |
The form-feed character ('\u000C') |
|
\a |
The alert (bell) character ('\u0007') |
|
\e |
The escape character ('\u001B') |
|
\cx |
The control character corresponding to x |
|
|
|
|
Character Classes | |
|
[abc] |
a, b, or c (simple class) |
|
[^abc] |
Any character except a, b, or c (negation) |
|
[a-zA-Z] |
a through z or A through Z, inclusive (range) |
|
[a-z-[bc]] |
a through z, except for b and c: [ad-z] (subtraction) |
|
[a-z-[m-p]] |
a through z, except for m through p: [a-lq-z] |
|
[a-z-[^def]] |
d, e, or f |
|
|
|
|
Predefined Character Classes | |
|
. |
Any character (may or may not match line terminators) |
|
\d |
A digit: [0-9] |
|
\D |
A non-digit: [^0-9] |
|
\s |
A whitespace character: [ \t\n\x0B\f\r] |
|
\S |
A non-whitespace character: [^\s] |
|
\w |
A word character: [a-zA-Z_0-9] |
|
\W |
A non-word character: [^\w] |
보다 자세한 설명과 예제는 J2SE 1.4 API 문서의 java.util.regex.Pattern 을 참조하도록 하자.
클래스와 메소드
Pattern 클래스
Pattern 객체는 Perl 문법과 비슷한 형태로 정의된 정규표현식을 나타낸다.
문자열로 정의한 정규표현식은 사용되기 전에 반드시 Pattern 클래스의 인스턴스로 컴파일되어야 한다. 컴파일된 패턴은 Matcher 객체를 만드는 데 사용되며, Matcher 객체는 임의의 입력 문자열이 패턴에 부합되는 지 여부를 판가름하는 기능을 담당한다. 또한 Pattern 객체들은 비상태유지 객체들이기 때문에 여러 개의 Matcher 객체들이 공유할 수 있다.
다음은 Pattern 클래스의 주요 메소드들에 대한 설명이다.
static Pattern compile(String regex) : 주어진 정규표현식으로부터 패턴을 만들어낸다(이를 ‘컴파일 한다’고 표현한다).
static Matcher matcher (CharSequence input) : 입력 캐릭터 시퀀스에서 패턴을 찾는 Matcher 객체를 만든다.
String[] pattern() : 컴파일된 정규표현식을 String 형태로 반환한다.
String[] split(CharSequence input) : 주어진 입력 캐릭터 시퀀스를 패턴에 따라 분리한다.
/*
* split 메소드를 이용해 입력 시퀀스를 콤마(‘,’)와 공백 문자를 기준으로
* 나눈다.
*/
import java.util.regex.*;
public class Splitter {
public static void main(String[] args) throws Exception {
// 한 개 이상의 연속된 ‘,’와 공백문자를 의미하는 패턴을 만든다.
Pattern p = Pattern.compile("[,{space}]+");
// 패턴에 따라 입력 문자열을 쪼갠다.
String[] result =
p.split("one,two, three four , five");
for (int i=0; i<result.length; i++)
System.out.println(result[i]);
}
}
Matcher 클래스
Matcher 객체는 특정한 문자열이 주어진 패턴과 일치하는가를 알아보는데 이용된다. Matcher 클래스의 입력값으로는 CharSequence라는 새로운 인터페이스가 사용되는데 이를 통해 다양한 형태의 입력 데이터로부터 문자 단위의 매칭 기능을 지원 받을 수 있다. 기본적으로 제공되는 CharSequence 객체들은 CharBuffer, String, StringBuffer 클래스가 있다.
Matcher 객체는 Pattern 객체의 matcher 메소드를 통해 얻어진다. Matcher 객체가 일단 만들어지면 주로 세 가지 목적으로 사용된다.
l 주어진 문자열 전체가 특정 패턴과 일치하는 가를 판단(matches).
l 주어진 문자열이 특정 패턴으로 시작하는가를 판단(lookingAt).
l 주어진 문자열에서 특정 패턴을 찾아낸다(find).
이들 메소드는 성공 시 true를 실패 시 false 를 반환한다.
또한 특정 문자열을 찾아 새로운 문자열로 교체하는 기능도 제공된다.
appendRepalcement(StringBuffer sb, String replacement) 메소드는 일치하는 패턴이 나타날 때까지의 모든 문자들을 버퍼(sb)로 옮기고 찾아진 문자열 대신 교체 문자열(replacement)로 채워 넣는다. 또한 appendTail(StringBuffer sb) 메소드는 캐릭터 시퀀스의 현재 위치 이후의 문자들을 버퍼(sb)에 복사해 넣는다. 다음 절에 나오는 예제 코드를 참고하도록 하자.
CharSequence 인터페이스
CharSequence 인터페이스는 다양한 형태의 캐릭터 시퀀스에 대해 일관적인 접근 방법을 제공하기 위해 새로 생겨났다. 기본적으로 String, StringBuffer, CharBuffer 클래스가 이를 구현하고 있으므로 적절한 것을 골라 사용하면 되며, 인터페이스가 간단하므로 필요하면 직접 이를 구현해 새로 하나 만들어도 된다.
Example Regex Scenarios
아래 코드는 J2SE 1.4 도큐먼트의 예제를 완성한 것이다.
/*
* 이 코드는 "One dog, two dogs in the yard." 라는 문자열을
* 표준 출력을 통해 출력한다.
*/
import java.util.regex.*;
public class Replacement {
public static void main(String[] args)
throws Exception {
// ‘cat’이라는 패턴 생성
Pattern p = Pattern.compile("cat");
// 입력 문자열과 함께 매쳐 클래스 생성
Matcher m = p.matcher("one cat," +
" two cats in the yard");
StringBuffer sb = new StringBuffer();
boolean result = m.find();
// 패턴과 일치하는 문자열을 ‘dog’으로 교체해가며
// 새로운 문자열을 만든다.
while(result) {
m.appendReplacement(sb, "dog");
result = m.find();
}
// 나머지 부분을 새로운 문자열 끝에 덫붙인다.
m.appendTail(sb);
System.out.println(sb.toString());
}
}
메일 주소 포맷 확인
다음 코드는 주어진 입력 시퀀스가 메일 주소 포맷인가를 판단한다. 이 코드는 가능한 모든 형태의 메일 주소를 확인하는 것은 아니니 필요하면 코드를 더 추가해 사용하자.
/*
* 메일 주소에서 잘못된 문자 검사
*/
public class EmailValidation {
public static void main(String[] args)
throws Exception {
String input = "@sun.com";
//메일 주소가 ‘.’이나 ‘@’와 같은 잘못된 문자로 시작하는 지 확인
Pattern p = Pattern.compile("^\\.|^\\@");
Matcher m = p.matcher(input);
if (m.find())
System.err.println("Email addresses don't start" +
" with dots or @ signs.");
//’www.’으로 시작하는 주소를 찾는다.
p = Pattern.compile("^www\\.");
m = p.matcher(input);
if (m.find()) {
System.out.println("Email addresses don't start" +
" with \"www.\", only web pages do.");
}
p = Pattern.compile("[^A-Za-z0-9\\.\\@_\\-~#]+");
m = p.matcher(input);
StringBuffer sb = new StringBuffer();
boolean result = m.find();
boolean deletedIllegalChars = false;
while(result) {
deletedIllegalChars = true;
m.appendReplacement(sb, "");
result = m.find();
}
m.appendTail(sb);
input = sb.toString();
if (deletedIllegalChars) {
System.out.println("It contained incorrect characters" +
" , such as spaces or commas.");
}
}
}
파일에서 제어 문자 제거
/*
* 지정된 파일에서 제어 문제를 찾아 제거한다.
*/
import java.util.regex.*;
import java.io.*;
public class Control {
public static void main(String[] args)
throws Exception {
//파일 객체 생성
File fin = new File("fileName1");
File fout = new File("fileName2");
//입출력 스트림 생성
FileInputStream fis =
new FileInputStream(fin);
FileOutputStream fos =
new FileOutputStream(fout);
BufferedReader in = new BufferedReader (
new InputStreamReader(fis));
BufferedWriter out = new BufferedWriter (
new OutputStreamWriter(fos));
// 제어문자를 의미하는 패턴 생성
Pattern p = Pattern.compile("{cntrl}");
Matcher m = p.matcher("");
String aLine = null;
while((aLine = in.readLine()) != null) {
m.reset(aLine);
//제어 문자들을 빈 문자열로 대체
String result = m.replaceAll("");
out.write(result);
out.newLine();
}
in.close();
out.close();
}
}
파일 검색
/*
* .java 파일에서 주석을 찾아 출력한다.
*/
import java.util.regex.*;
import java.io.*;
import java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;
public class CharBufferExample {
public static void main(String[] args) throws Exception {
// 주석을 나타내는 패턴 생성
Pattern p =
Pattern.compile("//.*$", Pattern.MULTILINE);
// 소스파일
File f = new File("Replacement.java");
FileInputStream fis = new FileInputStream(f);
FileChannel fc = fis.getChannel();
// 소스 파일로부터 CharBuffer 생성
ByteBuffer bb =
fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
Charset cs = Charset.forName("8859_1");
CharsetDecoder cd = cs.newDecoder();
CharBuffer cb = cd.decode(bb);
// 매칭 작업 수행
Matcher m = p.matcher(cb);
while (m.find())
System.out.println("Found comment: "+m.group());
}
}
결론
이제 자바의 패턴 매칭 능력은 다른 언어 부럽지 않은 수준까지 다다르게 되었다. 정규 표현식은 데이터베이스 또는 다른 어플리케이션에 데이터를 넘기기 전에 그 데이터가 정확한 포맷을 지키고 있는 지 검증할 때, 또는 다양한 목적의 관리 작업에 사용될 수 있을 것이다. 간단히 말해 패턴 매칭이 필요한 모든 자바 프로그램에서 이제 정규표현식을 사용할 수 있게 되었다.
가볍고 쉬운 Ajax - jQuery 시작하기
출처 : http://blog.naver.com/kissin/70018447897
시작 하기 전에
jQuery는 2006년 초에 John Resig가 개발한 자바스크립트 라이브러리 이다. 전체 라이브러리가 55kb밖에는 안되는 초 경량이면서도 누구나 쉽게 브라우져 기반의 자바스크립트 프로그래밍을 쉽게 할 수 있을 뿐더러, Ajax또한 쉽게 구현 할 수 가 있다. 또한 플러그인 방식의 확장을 지원하여, 현재 많은 수의 플러그인을 확보하고 있다.
나온지는 얼마 안되었지만 수백여개의 사이트가 사용할 만큼 안정적이며, 유명한 라이브러리 이다. 구지 비교하자면 prototype이라는 기존 유명 라이브러리와 비교가 가능하겠지만, 더욱 간단하며, 쉽다는것을 장점으로 꼽고 있다.(사실 본인은 prototype을 잘 모른다. 따라서 기존 개발자들의 의견을 빌린것이다. 어느것이 더 좋다는 표현이 아님을 알아달라)
무엇이 짧은 시간안에 jQuery를 유명하게 하였을까? 이런 호기심을 가지고 깊이 살펴본 결과 그 이유를 알 수 있었다. 작고, 쉽고, 그러나 강력하다는 것이 그 이유이다. 따라서 이런 본인의 경험을 공유하고자 이글을 올린다.
이 글은 jQuery의 튜토리얼문서를 기반으로하여 작성 되었다. 따라서 예제의 상당 부분은 동일하다, 단, 직접 프로그래밍을 통해 소스를 돌려보고 그 경험을 글로 올리는것이니 만큼 그냥 번역 보다는 더 나을 것으로 판단 한다.
참고로 이글에서 Ajax는 비동기 통신의 경우에만 국한 하겠다. 그 이유는 jQuery에서 Ajax라는 별도 네임스페이스로 라이브러리를 지원하기 때문이다.
프로그래머들 중에는 IDE를 싫어하는 사람도 있다. 그러나 나는 없는것보다는 있는것이 더 낳다고 생각한다. 특히 한 언어를 위한 전용 환경을 지원할 경우는 더욱 그러하다. 브라우져 기반의 자바스크립트 프로그래밍을 하다보면 가장 어려운 점이 디버깅이다. printf디버거도 어려울 경우가 많다.(printf디버거는 디버깅을 위해 필요한 값을 출력하여 확인 하는 방법을 말한다.-본인이 만들어낸 용어이다.) 특히 브라우져의 경우는 로컬파일을 사용할 수 없어 화면을 이용한 값의 출력에 의존하여야 함으로 루프값을 출력할 경우는 거의 죽음이고, HTML태그를 생성하여 이곳에 이벤트를 결합하고, 코딩하는것을 반복하는 동적 HTML프로그래밍은 더욱 디버깅이 어렵다. 따라서 브라우져의 플러그인과 결합된 디버거를 사용하는것이 매우 도움이 된다.
Firefox용 Firebug가 대표적인 것인데, 가장 많이 사용하는 디버거 이기도 하다. 그러나 편집기와 독립된 형태로 사용해야 함으로 수정 작업 시 불편함이 따른다. 이러한 점을 개선하려면 역시 디버거와 편집기를 포함하는 전용 IDE가 필요하다.
한가지더 이야기 하면, 기존 Eclipse와 같은 IDE에서 지원하는 Code Inspector기능의 필요를 들 수 있다. 사실 한 언어에 익숙한 사람이면 이 기능이 불편 하다. 매번 객체명뒤 점을 찍어 객체의 맴버를 보는 것은 그것을 아는 사람에게는 편집속도만 떨어뜨릴 뿐이다. 그러나 언어에 익숙치 않다거나, 남이 제공한 라이브러리를 사용할 경우는 이기능이 매우 유용하다. 특히 해당 맴버의 간단한 도움말까지 표시되면 API문서를 일일이 그때마다 검색하지 않아도 되어서 편리하다.
기존 자바 스크립트 편집기는 사실 이러한 기능이 부족한것이 사실 이었다. 그러나 지금 소개할 Aptana는 자바스크립트 전용 IDE를 표방한 몇 안되는 IDE중 하나이다. 이클립스 기반에 프러그인으로 개발되고 배포는 리치클라이언트와 플러그인 방식 모두를 지원한다. 따라서 기존 설치된 이클립스에서도 사용할 수 있고, 별도 설치를 통해 독립적인 IDE로 사용 할수도 있다. 다음은 Aptana의 실행 화면이다.
특히 Code Inspector가 매력 적이다. 노란 색으로 나오는 도움말도 매우 유용하다.
Apatana의 설치는 쉽다. 또한 무료로 사용 할 수 가 있다. (http://www.aptana.org/)
사용법은 기존 Eclipse와 동일하다. 단 디버거를 사용하려면 Firefox가 설치 되어 있어야 한다.
또한 기존 Ajax라이브러리들도 지원하는데, jQuery도 지원한다. 위 화면에서 객체의 도움말이 나올 수 있는것은 이 때문이다. 프로젝트 생성 시 jQuery프로젝트를 선택하여 생성 하면 된다.
위에서 소개한 Aptana를 설치 하였다면, 별도 jQuery설치는 필요 없다. 하지만 설치가 어려운것은 아니다. jQuery라이브러리는 55kb짜리 파일 하나로 되어 있다. 이를 HTML에 사용 선언을 하여 주면 된다.
<html>
<head>
<script type="text/javascript" src="path/jquery.js"></script>
<script type="text/javascript">
// Your code goes here
</script>
</head>
<body>
<a href="http://jquery.com/">jQuery</a>
</body>
</html>
기존 자바 스크립트 라이브러리 사용과 차이가 없다. 단, 압축버젼과 그렇지 않은 버젼 두개의 파일을 제공하는데, 프로그래밍을 할 때는 디버깅을 위해 압축하지 않은 버젼의 파일을 사용하고, 배포할 경우 압축된 버젼을 사용하는 것이 좋다.
보통의 자바스크립트 프로그래머들은 브라우져의 document가 모두 다운로드 되어진 상태에서 코드를 시작하기위해 다음과 같은 이벤트에 스크립트 코드를 넣는다.
window.onload = function(){ ... }
그러나 이 경우 이미지 까지 다운로드가 모두 완료 된 후 이벤트가 호출되기 때문에, 큰이미지의 경우 실행속도가 늦은 것처럼 사용자에게 보일 수 있다. 따라서 jQuery는 이러한 문제를 해결하기위해 다음과 같은 이벤트를 제공한다.
$(document).ready(function(){
// 이곳에 코드를 넣으면 된다.
});
이 이벤트는 브라우져의 document(DOM)객체가 준비가 되면 호출이 된다. 따라서 이미지 다운로드에 의한 지연이 없다.
위 코드는 다음과 같이 생략하여 사용 가능하다.
$(function() { // run this when the HTML is done downloading });
특정 태그를 클릭 했을경우 이벤트의 처리를 jQuery에서 어떻게 처리 하는지를 살펴 보자. 다음은 위 HTML예제의 앵커(a)태그 클릭 시 이벤트를 처리하는 코드 이다.
$("a").click(function(){
alert("Thanks for visiting!");
});
jQuery에서 이벤트 처리는 콜백함수를 통해 수행된다. 이코드는 HTML에 있는 모든 앵커 태그의 클릭 시 팦업창을 통해 메시지를 출력해 준다.
코드를 보면 $()로된 문법을 볼 수 있을 것이다. 이것은 jQuery의 셀렉터 이다. $("a")가 의미하는 것은 HTML(브라우져의 DOM)에서 앵커태그 모두를 의미한다. 이후 .click()메소드는 이벤트 메소드로서 이곳에 콜백함수를 파라메타로 넣어 이벤트 처리를 수행 하는것이다. 함수는 위에서 처럼 익명(function(){...})이나 선언된 함수 모두를 사용할 수 있다.
$()로 시작하는 셀렉터를 좀더 살펴보자. jQuery는 HTML, DOM객체등을 CSS나 XPATH의 쿼리방법과 동일한 방법으로 선택 한다. 앞선 예처럼 문자열로 특정 태그를 선택하는 것은 CSS를 작성해 본 프로그래머라면 익숙할 것이다. 이와 같은 방법 외에도 다음과 같이 태그의 id를 통해 선택 할 수 있다.
$(document).ready(function() {
$("#orderedlist").addClass("red");
});
위 코드는 id가 orderedlist인 태그에 red라는 CSS 클래스를 할당하는 코드 이다. 만약 이태그가 하위 태그를 가지고 있다면 다음과 같이 선택 할 수 있다.
$(document).ready(function() {
$("#orderedlist > li").addClass("blue");
});
이코드는 id가 orderedlist인 태그의 하위 태그 중 <li> 태그 모두에 blue라는 CSS 클래스를 할당하는 코드 이다. 이코드는 jQuery메소드를 이용 다음과 같이 바꾸어 사용 할 수도 있다.
$(document).ready(function() {
$("#orderedlist").find("li").each(function(i) {
$(this).addClass("blue");
});
});
한가지 다른 점은 모든 태그에 동일하게 CSS 클래스를 적용하는 방식이 아닌 개별 태그를 선택하여 적용할 수 있다는 것이다.
XPath를 사용하는 예를 다음과 같은 것을 들 수 있다
//절대 경로를 사용하는 경우
$("/html/body//p")
$("/*/body//p")
$("//p/../div")
//상대경로를 사용하는 경우
$("a",this)
$("p/a",this)
다음과 같이 두 방식을 혼용하여 사용 할 수도 있다.
//HTML내 모든 <p>태그중 클래스속성이 foo인 것 중 내부에 <a> 태그를 가지고 있는것
$("p.foo[a]");
//모든 <li>태그 중 Register라는 택스트가 들어있는 <a> 태그
$("li[a:contains('Register')]");
//모든 <input>태그 중 name속성이 bar인 것의 값
$("input[@name=bar]").val();
이외에도 jQuery는 CSS 3.0 표준을 따르고 있어 기존 보다 더많은 쿼리 방법을 지원하고 있다. 자세한것은 jQuery의 API 설명을 참고 하라(http://docs.jquery.com/Selectors)
jQuery는 코드의 양을 줄이기 위해 특별한 기능을 제공한다. 다음 코드를 보자
$("a").addClass("test").show().html("foo");
<a>태그에 test라는 CSS 클래스를 할당한다. 그후 태그를 보이면서 그안에 foo라는 텍스트를 넣는다. 이런 문법이 가능한 이유는 $(), addClass(), show()함수 모두가 <a>태그에 해당하는 객체를 결과로 리턴해주면 된다. 이를 Chainability라 한다. 좀더 복잡한 경우를 보자
$("a")
.filter(".clickme")
.click(function(){
alert("You are now leaving the site.");
})
.end()
.filter(".hideme")
.click(function(){
$(this).hide();
return false;
})
.end();
// 대상 HTML이다
<a href="http://google.com/" class="clickme">I give a message when you leave</a>
<a href="http://yahoo.com/" class="hideme">Click me to hide!</a>
<a href="http://microsoft.com/">I'm a normal link</a>
중간에 end()함수는 filter()함수로 선택된 객체를 체인에서 끝는 역할을 한다. 위에서는 clickme클래스의 <a>태그 객체를 끊고 hideme를 선택하는 예이다. 또한 this는 선택된 태그 객체를 말한다.
이런 Chainability를 지원 하는 jQuery메소드들에는 다음과 같은 것들이 있다.
위에서 click()이벤트를 콜백함수를 통해처리하는 코드를 살펴 보았다. 콜백함수는 기존 자바나 .NET의 그것과 같다. 다음 코드를 보자
$.get('myhtmlpage.html', myCallBack);
먼저 $.get()은 서버로 부터 HTML(또는 HTML 조각)을 가져오는 함수 이다. 여기서 myCallBack함수는 전송이 완료 되면 호출되는 콜백 함수 이다. 물론 앞선 예의
click()이벤트 콜백처럼 익명함수 function(){}을 사용 해도 된다. 그러나 이와 같이 미리 선언된 함수를 콜백으로 사용할 경우 파라메타의 전달 방법은 좀 다르다. 흔히 다음과 같이 하면 될것이라 생각할 것이다.
$.get('myhtmlpage.html', myCallBack(param1, param2));
그러나 위와 같은것은 자바스크립트의 클로져(closure)사용에 위배가 된다. 클로져는 변수화 될수 있는 코드 블록을 이야기한다. 즉 스트링변수와 같이 파라메타로 전달될 수 있지만, 실행가능한 함수 인 것이다. 일반적으로 함수를 ()제외하고 이름만을 사용하면 클로져가 된다. 위의경우 $get()함수의 파라메타로 전달된 myCallBack함수는 클로져로 전달된것이 아닌 myCallBack()를 실행한 결과 값이 전달 된다. 따라서 다음과 같이 코드를 작성하여야 한다.
$.get('myhtmlpage.html', function(){
myCallBack(param1, param2);
});
만약 선언된 함수가 아닌 익명함수를 콜백으로 사용할경우는 다음과 같이 하면 된다.
$.get('myhtmlpage.html', function(param1, param2){
//이곳에 코드를 넣는다.
});
HTML의 태그를 사라지고 나타내게 하거나, 늘리고 줄이고, 이동시키는 애니매이션 동작은 많이 사용하는 기는 중 하나이다. jQuery는 다양안 애니메이션 기능을 메소드를 통해 제공한다. 다음 코드를 보자
$(document).ready(function(){
$("a").toggle(function(){
$(".stuff").hide('slow');
},function(){
$(".stuff").show('fast');
});
});
이코드는 <a>태그중 stuff클래스가 할당된것을 토글로 느리게 감추고, 빨리 보이게 하는 함수 이다.
다음은 animate()메소드를 이용하여 여러 애니메이션을 합쳐 실행하는 예이다.
$(document).ready(function(){
$("a").toggle(function(){
$(".stuff").animate({ height: 'hide', opacity: 'hide' }, 'slow');
},function(){
$(".stuff").animate({ height: 'show', opacity: 'show' }, 'slow');
});
});
위 코드는 높이와 투명도를 동시에 천천히 사라지고, 나타나게 하는 코드 이다.
Ajax는 서버와의 비동기 통신을 말한다. 일반적으로 Ajax하면 요즘은 자바스크립트를 이용한 브라우져의 동적 DOM의 처리, 즉 DHTML, CSS등을 포함하지만, jQuery에서는 Ajax라는 네임스페이스를 통해 비동기 서버 통신을 하는것을 말한다.먼저 다음 예를 보자
$.ajax({
type: "GET",
url: "test.js",
dataType: "script"
})
이 예는 GET방식으로 서버에서 자바스크립트를 로딩하고 실행하는 코드 이다.
다음 예를 보자
$.ajax({
type: "POST",
url: "some.php",
data: "name=John&location=Boston",
success: function(msg){
alert( "Data Saved: " + msg );
}
});
이는 서버로 부터 POST방식으로 파라메터를 주어 데이터를 가져온 후 이를 success콜백을 이용해 처리하는 코드이다. 아마 Ajax에서 가장 많이 사용하는 코드일 것이다. success말고도 $.ajax()함수는 다양한 옵션을 제공한다. 자세한 내용은 API설명을 참조하라 (http://docs.jquery.com/Ajax)
다음 예는 이 옵션 중 async(비동기)방식을 사용할지 아닐지를 사용한 코드이다.
var html = $.ajax({
url: "some.php",
async: false
}).responseText;
지금까지 jQuery에 대해 간단히 살펴 보았다. 혹자는 Dojo나 Extjs와 같이 버튼, 그리드등의 위젯이 지원되지 않는다고 실망할 것이다.그러나 jQuery는 Plugin을 지원한다. 이중 Interface와 같은 플러그인은 그 완성도가 매우 높다. 이것 말고도 수백개의 플러그인들이 홈페이지를 통해 공개 되어 있다.(http://docs.jquery.com/Plugins)
하지만 내 경험상으로 그리드와 같은 복잡한 위젯이 아니더라도 자바스크립크를 이용한 동적인 홈페이지와 Ajax를 통한 비통기 통신만으로도 대부분의 고객 요구와 문제를 해결 할 수 있다. 실제로 jQuery는 MSNBC와 같은 유명한 많은 사이트에서 사용되고 있다.(http://docs.jquery.com/Sites_Using_jQuery)
따라서 어떤 서비스를 제공하느냐에 따라 필요한 위젯을 플러그인을 사용하거나 직접 개발하여 사용하는것이 더 나은 전략이라 생각한다. 사실 미리 만들어진 위젯도 나에게 맞추어 사용하기 위해서는 그래픽, CSS등 많은 부분을 손 대야 한다. 차라리 기본 원리를 알고 이를 확장하는 것이 좀더 전문적이고 어려운 문제를 해결 할 수 있는 길이라 생각 한다.
시간이 허락 한다면 꾸준히 jQuery의 개발 경험을 공유 하고 싶은 마음 이다.
출처 : http://blog.naver.com/kissin/70018447897
이 글은 스프링노트에서 작성되었습니다.
시스템 명령어
이 글은 스프링노트에서 작성되었습니다.
정규식 사용되는 String 객체의 메소드
메소드 리턴값
match(reg) 매치된 결과들의 내용을 Array 객체로 리턴 null
search(reg) 첫 번째 매치되는 문자열의 시작 index 값 -1
replace(reg) 1.첫 번째 매치된 reg를 rep로 교체하여 리턴한다
2.g속성이 사용되면 매치된 모든 문자열을 교체하여 바뀐 원본문자열
문자열 전체를 리턴한다.
split(reg,[n]) 문자열을 ㄱeg를 기준으로 잘라서 Array 객체로 리턴한다. 원본문자열
정규식(Regular Expression)
/^경훈/; "경훈" 로 시작하는 문자열 한 행과 매치되는 메타문자 ^
/경훈$/; "경훈" 로 끝나는 문자열 한 행과 매치되는 메타문자 $
/경훈/; 문자열 "경훈" 와 매치되는 정규식의 일반문자.
정규식의 속성(i, g, m)
m = 여러 줄에 대한 검색.
/주리/g; g 속성은 문자열 전역검색
/주리/i; i 속성은 대문자와 소문자를 구분하지 않음
/주리/gi; g 와 i 속성( 대소문자 구분없이 전역검색)
--------------------------------------------------------------
var rap = /\s/g; // 공백검사 g 는 전역검색
nid = document.form.id.value; // id 값
nid = nid.replace(rap,""); // 공백을 제거한다.
if(nid == "" || nid.length < 0){
return false;
}
--------------------------------------------------------------
-------------------------------------------------------------------------------
정규식 문자 매치되는 문자 정규식 문자 매치되는 문자 (\ = 역슬러시 이다)
\n 줄 바꿈 문자 \* * 문자
\r 리턴 \+ + 문자
\t 탭 \? ? 문자
\v 수직 탭 \( ( 문자
[\b] Backspace 문자 \) ) 문자
\cX 컨트롤 문자 ^X \[ [ 문자
\/ / 문자 \] ] 문자
\\ \ 문자 \{ { 문자
\. . 문자 \} } 문자
----------------------------------------------------------------------------------
정규식의 메타문자
[] : [abc]는 문자 "a","b","c" 중에 하나의 문자와 매치되는 것
a ┏ reg1 = /강/; reg2=/아/; reg3=/지/;
b ┗ reg4 = /[강아지]/; // a,b 같은 의미
[^] : [^abc]는 a b c 제외한 임의의 한 문자와 매치되는 것
단축 문자 클래스
1. /[a-z]/; [abcdefghij...z] 같다
2. /[A-Z]/; [ABCD.........Z] 같다
3. /[0-9]/; [0123456789] 같다
4. /[a-zA-Z0-9]/; 1,2,3 다 포함시킨다.
5. /[^a-zA-Z0-9]/; 영문자와 숫자를 제외한 모든 문자에 매치
메타문자 단축 문자 클래스
\s --> [\t\n\r\f\v] 임의의 공백문자(출력 되지 않는 문자들)
문자의 반복과 반복기호
{} ?, + ,*
괄호() 메타문자
n1=/곰/; n2=/개/; n3=/말/; n4=/송아지/; n5=/양/;
reg = /[곰개말(송아지)양]/;
reg1 = /D(HTML)?/; "D", "DHTML" 과 매치된다
reg2 = /D(HTML|html)?/; "D", "DHTML" ,"html 과 매치된다.
reg3 = /Ok{3}/; "Okkk" 에 매치된다
reg4 = /(Ok){3}/; "OkOkOk" 에 매치된다.
() 부분표현식
str = "문자열 javascript";
reg = /(java)(script)/;
// reg = /(java+)(script+)/;
a = str.match(reg); // Array 객체다 a[0],a[1].....
단어의 경계나 공백에 매치되는 앵커 메타문자
\s /\sHTML\s/; 앞뒤로 공백이 있는 " HTML " 문자에 매치된다.
\b /HTML\b/; "HTML" 로 끝나는 단어에 매치된다.
-----------------------------------------------------------------------------
예) reg = /^\d|[^a-zA-Z0-9]/g; : 첫 글자가 숫자인 것 또는 영문자나 숫자가
아닌것과 매치
--------------------------------------------------------------------------------
출처 : http://blog.naver.com/rakis77?Redirect=Log&logNo=70021929239
sc.exe failure ClickSpyService reset= 3600 actions= restart/60000/restart/600000/restart/600000