午夜精品久久久久久,亚洲高清影视,国产一区二区高清不卡

[转]字符转换

megax — Thu, 07 Aug 2008 12:18:00 GMT

一 C++ �?string与wstring互�{

�Ҏ(gu��)��一�Q?/p>

string WideToMutilByte(const wstring& _src)
{
int nBufSize = WideCharToMultiByte(GetACP(), 0, _src.c_str(),-1, NULL, 0, 0, FALSE);

char *szBuf = new char[nBufSize];

WideCharToMultiByte(GetACP(), 0, _src.c_str(),-1, szBuf, nBufSize, 0, FALSE);

string strRet(szBuf);

delete []szBuf;
szBuf = NULL;

return strRet;
}

wstring MutilByteToWide(const string& _src)
{
//计算字符�?string 转成 wchar_t 之后占用的内存字节数
int nBufSize = MultiByteToWideChar(GetACP(),0,_src.c_str(),-1,NULL,0);

//�?wsbuf 分配内存 BufSize 个字�?br>wchar_t *wsBuf = new wchar_t[nBufSize];

//转化�?unicode �?WideString
MultiByteToWideChar(GetACP(),0,_src.c_str(),-1,wsBuf,nBufSize);

wstring wstrRet(wsBuf);

delete []wsBuf;
wsBuf = NULL;

return wstrRet;
}

转蝲�Q�csdn

�q�篇文章里，我将�l�出几种C++ std::string和std::wstring�怺�转换的�{换方法�?br>
�W�一�U�方法：调用WideCharToMultiByte()和MultiByteToWideChar()�Q�代码如下（关于详细的解释，可以参考《windows核心�~�程》）�Q?br>

#include
#include
using namespace std;
//Converting a WChar string to a Ansi string
std::string WChar2Ansi(LPCWSTR pwszSrc)
{
         int nLen = WideCharToMultiByte(CP_ACP, 0, pwszSrc, -1, NULL, 0, NULL, NULL);

         if (nLen<= 0) return std::string("");

         char* pszDst = new char[nLen];
         if (NULL == pszDst) return std::string("");

         WideCharToMultiByte(CP_ACP, 0, pwszSrc, -1, pszDst, nLen, NULL, NULL);
         pszDst[nLen -1] = 0;

         std::string strTemp(pszDst);
         delete [] pszDst;

         return strTemp;
}

string ws2s(wstring& inputws)
{
return WChar2Ansi(inputws.c_str());
}

//Converting a Ansi string to WChar string

std::wstring Ansi2WChar(LPCSTR pszSrc, int nLen)

{
    int nSize = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pszSrc, nLen, 0, 0);
    if(nSize <= 0) return NULL;

         WCHAR *pwszDst = new WCHAR[nSize+1];
    if( NULL == pwszDst) return NULL;

    MultiByteToWideChar(CP_ACP, 0,(LPCSTR)pszSrc, nLen, pwszDst, nSize);
    pwszDst[nSize] = 0;

    if( pwszDst[0] == 0xFEFF)                    // skip Oxfeff
        for(int i = 0; i < nSize; i ++)
                            pwszDst[i] = pwszDst[i+1];

    wstring wcharString(pwszDst);
         delete pwszDst;

    return wcharString;
}

std::wstring s2ws(const string& s)
{
return Ansi2WChar(s.c_str(),s.size());
}

�W�二�U�方法：采用ATL��装_bstr_t的过渡：�Q�注�Q�_bstr_是Microsoft Specific的，所以下面代码可以在VS2005通过�Q�无�U�L��性）�Q?/p>

#include
#include
using namespace std;
#pragma comment(lib, "comsuppw.lib")

string ws2s(const wstring& ws);
wstring s2ws(const string& s);

string ws2s(const wstring& ws)
{
         _bstr_t t = ws.c_str();
         char* pchar = (char*)t;
         string result = pchar;
         return result;
}

wstring s2ws(const string& s)
{
         _bstr_t t = s.c_str();
         wchar_t* pwchar = (wchar_t*)t;
         wstring result = pwchar;
         return result;
}

�W�三�U�方法：使用CRT库的mbstowcs()函数和wcstombs()函数�Q��^台无养I��需讑֮�locale�?/p>

#include
#include
using namespace std;
string ws2s(const wstring& ws)
{
         string curLocale = setlocale(LC_ALL, NULL);        // curLocale = "C";

         setlocale(LC_ALL, "chs");

         const wchar_t* _Source = ws.c_str();
         size_t _Dsize = 2 * ws.size() + 1;
         char *_Dest = new char[_Dsize];
         memset(_Dest,0,_Dsize);
         wcstombs(_Dest,_Source,_Dsize);
         string result = _Dest;
         delete []_Dest;

         setlocale(LC_ALL, curLocale.c_str());

         return result;
}

wstring s2ws(const string& s)
{
         setlocale(LC_ALL, "chs");

         const char* _Source = s.c_str();
         size_t _Dsize = s.size() + 1;
         wchar_t *_Dest = new wchar_t[_Dsize];
         wmemset(_Dest, 0, _Dsize);
         mbstowcs(_Dest,_Source,_Dsize);
         wstring result = _Dest;
         delete []_Dest;

         setlocale(LC_ALL, "C");

         return result;
}

�?utf8.utf16.utf32的相互�{�?/p>

可以参考Unicode.org 上有ConvertUTF.c和ConvertUTF.h �Q�下载地址�Q?a >http://www.unicode.org/Public/PROGRAMS/CVTUTF/�Q?/p>

实现文�gConvertUTF.c�Q�（.h省）
/**//*
* Copyright 2001-2004 Unicode, Inc.
*
* Disclaimer
*
* This source code is provided as is by Unicode, Inc. No claims are
* made as to fitness for any particular purpose. No warranties of any
* kind are expressed or implied. The recipient agrees to determine
* applicability of information provided. If this file has been
* purchased on magnetic or optical media from Unicode, Inc., the
* sole remedy for any claim will be exchange of defective media
* within 90 days of receipt.
*
* Limitations on Rights to Redistribute This Code
*
* Unicode, Inc. hereby grants the right to freely use the information
* supplied in this file in the creation of products supporting the
* Unicode Standard, and to make copies of this file in any form
* for internal or external distribution as long as this notice
* remains attached.
*/

/**//* ---------------------------------------------------------------------

    Conversions between UTF32, UTF-16, and UTF-8. Source code file.
    Author: Mark E. Davis, 1994.
    Rev History: Rick McGowan, fixes & updates May 2001.
    Sept 2001: fixed const & error conditions per
    mods suggested by S. Parent & A. Lillich.
    June 2002: Tim Dodd added detection and handling of incomplete
    source sequences, enhanced error detection, added casts
    to eliminate compiler warnings.
    July 2003: slight mods to back out aggressive FFFE detection.
    Jan 2004: updated switches in from-UTF8 conversions.
    Oct 2004: updated to use UNI_MAX_LEGAL_UTF32 in UTF-32 conversions.

See the header file "ConvertUTF.h" for complete documentation.

------------------------------------------------------------------------ */

#include "ConvertUTF.h"
#ifdef CVTUTF_DEBUG
#include
#endif

static const int halfShift = 10; /**//* used for shifting by 10 bits */

static const UTF32 halfBase = 0x0010000UL;
static const UTF32 halfMask = 0x3FFUL;

#define UNI_SUR_HIGH_START (UTF32)0xD800
#define UNI_SUR_HIGH_END    (UTF32)0xDBFF
#define UNI_SUR_LOW_START   (UTF32)0xDC00
#define UNI_SUR_LOW_END     (UTF32)0xDFFF
#define false       0
#define true        1

/**//* --------------------------------------------------------------------- */

ConversionResult ConvertUTF32toUTF16 (
    const UTF32** sourceStart, const UTF32* sourceEnd,
    UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
    ConversionResult result = conversionOK;
    const UTF32* source = *sourceStart;
    UTF16* target = *targetStart;
    while (source < sourceEnd) {
    UTF32 ch;
    if (target >= targetEnd) {
        result = targetExhausted; break;
    }
    ch = *source++;
    if (ch <= UNI_MAX_BMP) { /**//* Target is a character <= 0xFFFF */
        /**//* UTF-16 surrogate values are illegal in UTF-32; 0xffff or 0xfffe are both reserved values */
        if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
        if (flags == strictConversion) {
            --source; /**//* return to the illegal value itself */
            result = sourceIllegal;
            break;
        } else {
            *target++ = UNI_REPLACEMENT_CHAR;
        }
        } else {
        *target++ = (UTF16)ch; /**//* normal case */
        }
    } else if (ch > UNI_MAX_LEGAL_UTF32) {
        if (flags == strictConversion) {
        result = sourceIllegal;
        } else {
        *target++ = UNI_REPLACEMENT_CHAR;
        }
    } else {
        /**//* target is a character in range 0xFFFF - 0x10FFFF. */
        if (target + 1 >= targetEnd) {
        --source; /**//* Back up source pointer! */
        result = targetExhausted; break;
        }
        ch -= halfBase;
        *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
        *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
    }
    }
    *sourceStart = source;
    *targetStart = target;
    return result;
}

/**//* --------------------------------------------------------------------- */

ConversionResult ConvertUTF16toUTF32 (
    const UTF16** sourceStart, const UTF16* sourceEnd,
    UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
    ConversionResult result = conversionOK;
    const UTF16* source = *sourceStart;
    UTF32* target = *targetStart;
    UTF32 ch, ch2;
    while (source < sourceEnd) {
    const UTF16* oldSource = source; /**//* In case we have to back up because of target overflow. */
    ch = *source++;
    /**//* If we have a surrogate pair, convert to UTF32 first. */
    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
        /**//* If the 16 bits following the high surrogate are in the source buffer */
        if (source < sourceEnd) {
        ch2 = *source;
        /**//* If it's a low surrogate, convert to UTF32. */
        if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
            ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
            + (ch2 - UNI_SUR_LOW_START) + halfBase;
            ++source;
        } else if (flags == strictConversion) { /**//* it's an unpaired high surrogate */
            --source; /**//* return to the illegal value itself */
            result = sourceIllegal;
            break;
        }
        } else { /**//* We don't have the 16 bits following the high surrogate. */
        --source; /**//* return to the high surrogate */
        result = sourceExhausted;
        break;
        }
    } else if (flags == strictConversion) {
        /**//* UTF-16 surrogate values are illegal in UTF-32 */
        if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
        --source; /**//* return to the illegal value itself */
        result = sourceIllegal;
        break;
        }
    }
    if (target >= targetEnd) {
        source = oldSource; /**//* Back up source pointer! */
        result = targetExhausted; break;
    }
    *target++ = ch;
    }
    *sourceStart = source;
    *targetStart = target;
#ifdef CVTUTF_DEBUG
if (result == sourceIllegal) {
    fprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
    fflush(stderr);
}
#endif
    return result;
}

/**//* --------------------------------------------------------------------- */

/**//*
* Index into the table below with the first byte of a UTF-8 sequence to
* get the number of trailing bytes that are supposed to follow it.
* Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
* left as-is for anyone who may want to do such conversion, which was
* allowed in earlier algorithms.
*/
static const char trailingBytesForUTF8[256] = {
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
};

/**//*
* Magic values subtracted from a buffer value during UTF8 conversion.
* This table contains as many values as there might be trailing bytes
* in a UTF-8 sequence.
*/
static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL,
0x03C82080UL, 0xFA082080UL, 0x82082080UL };

/**//*
* Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
* into the first byte, depending on how many bytes follow. There are
* as many entries in this table as there are UTF-8 sequence types.
* (I.e., one byte sequence, two byte etc.). Remember that sequencs
* for *legal* UTF-8 will be 4 or fewer bytes total.
*/
static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };

/**//* --------------------------------------------------------------------- */

/**//* The interface converts a whole buffer to avoid function-call overhead.
* Constants have been gathered. Loops & conditionals have been removed as
* much as possible for efficiency, in favor of drop-through switches.
* (See "Note A" at the bottom of the file for equivalent code.)
* If your compiler supports it, the "isLegalUTF8" call can be turned
* into an inline function.
*/

/**//* --------------------------------------------------------------------- */

ConversionResult ConvertUTF16toUTF8 (
    const UTF16** sourceStart, const UTF16* sourceEnd,
    UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
    ConversionResult result = conversionOK;
    const UTF16* source = *sourceStart;
    UTF8* target = *targetStart;
    while (source < sourceEnd) {
    UTF32 ch;
    unsigned short bytesToWrite = 0;
    const UTF32 byteMask = 0xBF;
    const UTF32 byteMark = 0x80;
    const UTF16* oldSource = source; /**//* In case we have to back up because of target overflow. */
    ch = *source++;
    /**//* If we have a surrogate pair, convert to UTF32 first. */
    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
        /**//* If the 16 bits following the high surrogate are in the source buffer */
        if (source < sourceEnd) {
        UTF32 ch2 = *source;
        /**//* If it's a low surrogate, convert to UTF32. */
        if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
            ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
            + (ch2 - UNI_SUR_LOW_START) + halfBase;
            ++source;
        } else if (flags == strictConversion) { /**//* it's an unpaired high surrogate */
            --source; /**//* return to the illegal value itself */
            result = sourceIllegal;
            break;
        }
        } else { /**//* We don't have the 16 bits following the high surrogate. */
        --source; /**//* return to the high surrogate */
        result = sourceExhausted;
        break;
        }
    } else if (flags == strictConversion) {
        /**//* UTF-16 surrogate values are illegal in UTF-32 */
        if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
        --source; /**//* return to the illegal value itself */
        result = sourceIllegal;
        break;
        }
    }
    /**//* Figure out how many bytes the result will require */
    if (ch < (UTF32)0x80) {         bytesToWrite = 1;
    } else if (ch < (UTF32)0x800) {     bytesToWrite = 2;
    } else if (ch < (UTF32)0x10000) {   bytesToWrite = 3;
    } else if (ch < (UTF32)0x110000) { bytesToWrite = 4;
    } else {                bytesToWrite = 3;
                        ch = UNI_REPLACEMENT_CHAR;
    }

    target += bytesToWrite;
    if (target > targetEnd) {
        source = oldSource; /**//* Back up source pointer! */
        target -= bytesToWrite; result = targetExhausted; break;
    }
    switch (bytesToWrite) { /**//* note: everything falls through. */
        case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        case 1: *--target = (UTF8)(ch | firstByteMark[bytesToWrite]);
    }
    target += bytesToWrite;
    }
    *sourceStart = source;
    *targetStart = target;
    return result;
}

/**//* --------------------------------------------------------------------- */

/**//*
* Utility routine to tell whether a sequence of bytes is legal UTF-8.
* This must be called with the length pre-determined by the first byte.
* If not calling this from ConvertUTF8to*, then the length can be set by:
* length = trailingBytesForUTF8[*source]+1;
* and the sequence is illegal right away if there aren't that many bytes
* available.
* If presented with a length > 4, this returns false. The Unicode
* definition of UTF-8 goes up to 4-byte sequences.
*/

static Boolean isLegalUTF8(const UTF8 *source, int length) {
    UTF8 a;
    const UTF8 *srcptr = source+length;
    switch (length) {
    default: return false;
    /**//* Everything else falls through when "true" */
    case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
    case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
    case 2: if ((a = (*--srcptr)) > 0xBF) return false;

    switch (*source) {
        /**//* no fall-through in this inner switch */
        case 0xE0: if (a < 0xA0) return false; break;
        case 0xED: if (a > 0x9F) return false; break;
        case 0xF0: if (a < 0x90) return false; break;
        case 0xF4: if (a > 0x8F) return false; break;
        default:   if (a < 0x80) return false;
    }

    case 1: if (*source >= 0x80 && *source < 0xC2) return false;
    }
    if (*source > 0xF4) return false;
    return true;
}

/**//* --------------------------------------------------------------------- */

/**//*
* Exported function to return whether a UTF-8 sequence is legal or not.
* This is not used here; it's just exported.
*/
Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
    int length = trailingBytesForUTF8[*source]+1;
    if (source+length > sourceEnd) {
    return false;
    }
    return isLegalUTF8(source, length);
}

/**//* --------------------------------------------------------------------- */

ConversionResult ConvertUTF8toUTF16 (
    const UTF8** sourceStart, const UTF8* sourceEnd,
    UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
    ConversionResult result = conversionOK;
    const UTF8* source = *sourceStart;
    UTF16* target = *targetStart;
    while (source < sourceEnd) {
    UTF32 ch = 0;
    unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
    if (source + extraBytesToRead >= sourceEnd) {
        result = sourceExhausted; break;
    }
    /**//* Do this check whether lenient or strict */
    if (! isLegalUTF8(source, extraBytesToRead+1)) {
        result = sourceIllegal;
        break;
    }
    /**//*
     * The cases all fall through. See "Note A" below.
     */
    switch (extraBytesToRead) {
        case 5: ch += *source++; ch <<= 6; /**//* remember, illegal UTF-8 */
        case 4: ch += *source++; ch <<= 6; /**//* remember, illegal UTF-8 */
        case 3: ch += *source++; ch <<= 6;
        case 2: ch += *source++; ch <<= 6;
        case 1: ch += *source++; ch <<= 6;
        case 0: ch += *source++;
    }
    ch -= offsetsFromUTF8[extraBytesToRead];

    if (target >= targetEnd) {
        source -= (extraBytesToRead+1); /**//* Back up source pointer! */
        result = targetExhausted; break;
    }
    if (ch <= UNI_MAX_BMP) { /**//* Target is a character <= 0xFFFF */
        /**//* UTF-16 surrogate values are illegal in UTF-32 */
        if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
        if (flags == strictConversion) {
            source -= (extraBytesToRead+1); /**//* return to the illegal value itself */
            result = sourceIllegal;
            break;
        } else {
            *target++ = UNI_REPLACEMENT_CHAR;
        }
        } else {
        *target++ = (UTF16)ch; /**//* normal case */
        }
    } else if (ch > UNI_MAX_UTF16) {
        if (flags == strictConversion) {
        result = sourceIllegal;
        source -= (extraBytesToRead+1); /**//* return to the start */
        break; /**//* Bail out; shouldn't continue */
        } else {
        *target++ = UNI_REPLACEMENT_CHAR;
        }
    } else {
        /**//* target is a character in range 0xFFFF - 0x10FFFF. */
        if (target + 1 >= targetEnd) {
        source -= (extraBytesToRead+1); /**//* Back up source pointer! */
        result = targetExhausted; break;
        }
        ch -= halfBase;
        *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
        *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
    }
    }
    *sourceStart = source;
    *targetStart = target;
    return result;
}

/**//* --------------------------------------------------------------------- */

ConversionResult ConvertUTF32toUTF8 (
    const UTF32** sourceStart, const UTF32* sourceEnd,
    UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
    ConversionResult result = conversionOK;
    const UTF32* source = *sourceStart;
    UTF8* target = *targetStart;
    while (source < sourceEnd) {
    UTF32 ch;
    unsigned short bytesToWrite = 0;
    const UTF32 byteMask = 0xBF;
    const UTF32 byteMark = 0x80;
    ch = *source++;
    if (flags == strictConversion ) {
        /**//* UTF-16 surrogate values are illegal in UTF-32 */
        if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
        --source; /**//* return to the illegal value itself */
        result = sourceIllegal;
        break;
        }
    }
    /**//*
     * Figure out how many bytes the result will require. Turn any
     * illegally large UTF32 things (> Plane 17) into replacement chars.
     */
    if (ch < (UTF32)0x80) {         bytesToWrite = 1;
    } else if (ch < (UTF32)0x800) {     bytesToWrite = 2;
    } else if (ch < (UTF32)0x10000) {   bytesToWrite = 3;
    } else if (ch <= UNI_MAX_LEGAL_UTF32) { bytesToWrite = 4;
    } else {                bytesToWrite = 3;
                        ch = UNI_REPLACEMENT_CHAR;
                        result = sourceIllegal;
    }

    target += bytesToWrite;
    if (target > targetEnd) {
        --source; /**//* Back up source pointer! */
        target -= bytesToWrite; result = targetExhausted; break;
    }
    switch (bytesToWrite) { /**//* note: everything falls through. */
        case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        case 1: *--target = (UTF8) (ch | firstByteMark[bytesToWrite]);
    }
    target += bytesToWrite;
    }
    *sourceStart = source;
    *targetStart = target;
    return result;
}

/**//* --------------------------------------------------------------------- */

ConversionResult ConvertUTF8toUTF32 (
    const UTF8** sourceStart, const UTF8* sourceEnd,
    UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
    ConversionResult result = conversionOK;
    const UTF8* source = *sourceStart;
    UTF32* target = *targetStart;
    while (source < sourceEnd) {
    UTF32 ch = 0;
    unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
    if (source + extraBytesToRead >= sourceEnd) {
        result = sourceExhausted; break;
    }
    /**//* Do this check whether lenient or strict */
    if (! isLegalUTF8(source, extraBytesToRead+1)) {
        result = sourceIllegal;
        break;
    }
    /**//*
     * The cases all fall through. See "Note A" below.
     */
    switch (extraBytesToRead) {
        case 5: ch += *source++; ch <<= 6;
        case 4: ch += *source++; ch <<= 6;
        case 3: ch += *source++; ch <<= 6;
        case 2: ch += *source++; ch <<= 6;
        case 1: ch += *source++; ch <<= 6;
        case 0: ch += *source++;
    }
    ch -= offsetsFromUTF8[extraBytesToRead];

    if (target >= targetEnd) {
        source -= (extraBytesToRead+1); /**//* Back up the source pointer! */
        result = targetExhausted; break;
    }
    if (ch <= UNI_MAX_LEGAL_UTF32) {
        /**//*
         * UTF-16 surrogate values are illegal in UTF-32, and anything
         * over Plane 17 (> 0x10FFFF) is illegal.
         */
        if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
        if (flags == strictConversion) {
            source -= (extraBytesToRead+1); /**//* return to the illegal value itself */
            result = sourceIllegal;
            break;
        } else {
            *target++ = UNI_REPLACEMENT_CHAR;
        }
        } else {
        *target++ = ch;
        }
    } else { /**//* i.e., ch > UNI_MAX_LEGAL_UTF32 */
        result = sourceIllegal;
        *target++ = UNI_REPLACEMENT_CHAR;
    }
    }
    *sourceStart = source;
    *targetStart = target;
    return result;
}

/**//* ---------------------------------------------------------------------

    Note A.
    The fall-through switches in UTF-8 reading code save a
    temp variable, some decrements & conditionals. The switches
    are equivalent to the following loop:
    {
        int tmpBytesToRead = extraBytesToRead+1;
        do {
        ch += *source++;
        --tmpBytesToRead;
        if (tmpBytesToRead) ch <<= 6;
        } while (tmpBytesToRead > 0);
    }
    In UTF-8 writing code, the switches on "bytesToWrite" are
    similarly unrolled loops.

--------------------------------------------------------------------- */

�?C++ 的字�W�串与C#的�{�?/p>

1�Q�将system::String 转化为C++的string�Q?br>// convert_system_string.cpp
// compile with: /clr
#include
#include
using namespace std;
using namespace System;

void MarshalString ( String ^ s, string& os ) {
   using namespace Runtime::InteropServices;
   const char* chars =
      (const char*)(Marshal::StringToHGlobalAnsi(s)).ToPointer();
   os = chars;
   Marshal::FreeHGlobal(IntPtr((void*)chars));
}

void MarshalString ( String ^ s, wstring& os ) {
   using namespace Runtime::InteropServices;
   const wchar_t* chars =
      (const wchar_t*)(Marshal::StringToHGlobalUni(s)).ToPointer();
   os = chars;
   Marshal::FreeHGlobal(IntPtr((void*)chars));
}

int main() {
   string a = "test";
   wstring b = L"test2";
   String ^ c = gcnew String("abcd");

   cout << a << endl;
   MarshalString(c, a);
   c = "efgh";
   MarshalString(c, b);
   cout << a << endl;
   wcout << b << endl;
}

2�Q�将System::String转化为char*或w_char*
// convert_string_to_wchar.cpp
// compile with: /clr
#include < stdio.h >
#include < stdlib.h >
#include < vcclr.h >

using namespace System;

int main() {
String ^str = "Hello";

   // Pin memory so GC can't move it while native function is called
   pin_ptr wch = PtrToStringChars(str);
   printf_s("%S\n", wch);

   // Conversion to char* :
   // Can just convert wchar_t* to char* using one of the
   // conversion functions such as:
   // WideCharToMultiByte()
   // wcstombs_s()
   // etc
   size_t convertedChars = 0;
   size_t sizeInBytes = ((str->Length + 1) * 2);
   errno_t err = 0;
   char    *ch = (char *)malloc(sizeInBytes);

   err = wcstombs_s(&convertedChars,
                    ch, sizeInBytes,
                    wch, sizeInBytes);
   if (err != 0)
      printf_s("wcstombs_s failed!\n");

printf_s("%s\n", ch);
}

megax 2008-08-07 20:18 发表评论

[转]vi常用操作

megax — Tue, 11 Mar 2008 06:14:00 GMT

摘要: 1)文�g操作 vi FileName 打开文�g Fi... 阅读全文

megax 2008-03-11 14:14 发表评论

[转]Linux常见问题解答

megax — Tue, 11 Mar 2008 06:12:00 GMT

一�?如何建立多用�?br>　　adduser newuser接着输入命��opasswd newuser�Q�屏�q�将提示输入口��o�Q�再�ơ输入确认，一个新的用户就增加成功
　　Linux提供了六个虚拟控制台�Q�用ALT+F1~F6切换�Q�在X-window下用CRTL+ALT+F1~F6切换�Q�，每个控制台均可以用不同的用户��d��Q�运行不同的�E�序�?/p>

二、在Linux下如何��用��Y盘、光盘以及DOS�{�非Linux分区

　　装蝲的命令是mount�Q�格式如下：mount -t 文�g�pȝ��c�d�� 讑֤��?装蝲目录

　　文�g�pȝ��c�d��是分区格式�Q�Linux支持的文件系�l�类型有许多�Q?/p>

　　msdos DOS分区文�g�pȝ��c�d��
　　vfat 支持长文件名的DOS分区文�g�Q�可以理解�ؓWindows文�g�Q�系�l�类�?br>　　iso9660 光盘的文件系�l�类�?br>　　ext2 Linux的文件系�l�类�?/p>

　　讑֤�名，指的是你要装载的讑֤�的名�U�。��Y盘一般�ؓ/dev/fd0 fd1�Q�光盘则�Ҏ(gu��)��你的光驱的位�|�来军_��Q�通常光驱装在�W�二��盘的主盘位�|�就�?dev/hdc;如果讉K��的是DOS的分区，则列出其讑֤�名，�?dev/hda1是指�W�一��盘的第一个分区�?装蝲目录�Q�就是你指定讑֤�的蝲入点�?/p>

　　1. 装蝲软盘

　　首先用mkdir /mnt/floppy �?mnt目录下徏立一个空的floppy目录�Q�然后输入mount -t msdos /dev/fd0 /mnt/floppy ��DOS文�g格式的一张��Y盘装载进来，以后��可以在/mnt/floppy目录下找到这张��Y盘的所有内宏V�?/p>

　　2. 装蝲Windows所在的C�?/p>

　　mkdir /mnt/c �?mnt目录下徏立一个空的c目录;
　　mount -t vfat /dev/hda1 /mnt/c ��Windows的C盘按长文件名格式装蝲�?mnt/c目录下，以后在该目录下就能读写C盘根目录中的内容�?/p>

　　3.装蝲光盘

　　mkdir /mnt/cdrom �?mnt目录下徏立一个空的cdrom目录;
　　mount -t iso9660 /dev/hdc /mnt/cdrom ��光盘蝲入到文�g�pȝ��中来�Q�将�?mnt/cdrom目录下找到光盘内宏V��有的Linux版本允许用mount /dev/cdrom或mount /mnt/cdrom命��o装蝲光盘�?br>　　要注意的是，用mount命��o装入的是软盘、光盘，而不是��Y驱、光驱。有些初学者容易犯一个毛病，以�ؓ用上面命令后�Q��Y驱就成了/mnt/floppy�Q�光驱就成了/mnt/cdrom�Q�其实不�Ӟ��当你要换一张光盘或软盘�Ӟ��一定要先卸载，再对新盘重新装蝲�?/p>

　　4.卸蝲

　　卸蝲的命令格式是:umonut 目录名，例如要卸载��Y盘，可输入命令umonut /mnt/floppy。要注意的是�Q�在卸蝲光盘之前�Q�直接按光驱面板上的弹出键是不会起作用的�?/p>

三、RPM的��用方�?/p>

1. 用RPM安装软�g�?�Q�rpm -ivh 软�g文�g�?br>　　例如 rpm -ivh fvwm95-2.0.43a.chinese-1.i386.rpm 屏幕上就会输��软�g包的名称和安装的�q�度�?
　　fvwm95 ###############
　　当进度条走到底，中文fvwm95�Q�一�U�X-Window的界面）��安装完了，再运行X-Window�Q�啊�Q�全中文的fvwm95��在我的眼前�?/p>

2. 用RPM反安装��Y件包:rpm -e 软�g�?br>　　例如:rpm -e fvwm95

3. 用RPM升��软�g�?rpm -Uvh 软�g升��版文件名
　　例如:rpm -Uvh fvwm95-2.1.0a.chinese-1.i386.rpm�Q�RPM自动反安装原来的老版本，��升�U�版的��Y件安装入�pȝ��?/p>

四、Linux开机直接进入文本界面，怎样才能让它默认�q�入囑�Ş界面�Q?/p>

修改/etc/inittab文�g�Q�其中有一行id:3:initdefault�Q�意思是说开机默认进入运行��?�Q�多用户的文本界面）�Q�把它改成id:5:initdefault�Q�既开机默认进入运行��?�Q�多用户的图形界面）。这样就行了�?/p>

五、如何将man转存为文本文�Ӟ��

以ls的man��Z��
man ls |col -b >ls.txt
��info变成文本,以make��Z��
info make -o make.txt -s

六、如何将��?man page 转成 HTML 格式�Q?/p>

使用 man2html �q�个指��o�Q�就可以��?man page 转成 HTML 格式了。用法是�Q?/p>

man2html filename > htmlfile.html

七�?tar�Q?tar.gz�Q?bz2�Q?tar.bz2�Q?bz�Q?gz是什么文�Ӟ��如何解开他们�Q?br>他们都是文�g(压羃)包�?br>.tar�Q�把文�g打包�Q�不压羃�Q�tar cvf *.tar dirName 解开�Q�tar xvf *.tar
.tar.gz�Q�把文�g打包�q�压�~�：tar czvf *.tar.gz dirName 解开�Q�tar xzvf *.tar.gz
.bz2�Q�解开�Q�bzip2 -d *.bz2
.bz�Q�解开�Q�bzip -d *.bz
.gz�Q�解开�Q�gzip -d *.gz

八、linux下如何解开.zip�Q?rar压羃文�g�Q?br>rh8下有一个图形界面的软�gfile-roller可以做这件事。��o外可以用unzip *.zip解开zip文�g�Q�unrar *.rar解开rar文�g�Q�不�q�unrar一般系�l�不自带�Q�要到网上下载�?/p>

�?ji��)、linux下如何浏�?iso光盘镜像文�g�Q?br>a.��Z��个目录，如：mkdir a
b.把iso文�g挂蝲到该目录上：mount -o loop xxxx.iso a
现在目录a里的内容��是iso文�g里的内容了�?/p>

十、linux下如何配�|�网�l�？
用netconfig�?#8220;IP address:”��是要配�|�的IP地址�Q?#8220;Netmask:”子网掩码�Q?#8220;Default gateway (IP):”�|�关�Q?#8220;Primary nameserver:”DNS服务器IP

十一、如何让linux启动后自动挂载制定分区？
�~�辑/etc/fstab文�g�Q�在里面加入相应的行

十二、如何定制linux启动时启动的服务�Q?br>在控制台或终端下�q�行ntsysv�Q�然后把要启动的服务选上�Q�如果要开��Z��启动某个那就把他的选中��L��?/p>

十三、删除文件大��ؓ零的文�g
rm -i `find ./ -size 0`
find ./ -size 0 -exec rm {} \;
find ./ -size |xargs rm -f &非常有效
for file in * #自己定义需要删除的文�g�c�d��
do
if [ ! -s ${file} ]
then
rm ${file}
echo “rm $file Success!”
fi
done

十四、查看系�l�信�?br>cat /proc/cpuinfo - CPU (i.e. vendor, Mhz, flags like mmx)
cat /proc/interrupts - 中断
cat /proc/ioports - 讑֤�IO端口
cat /proc/meminfo - 内存信息(i.e. mem used, free, swap size)
cat /proc/partitions - 所有设备的所有分�?br>cat /proc/pci - PCI讑֤�的信�?br>cat /proc/swaps - 所有Swap分区的信�?br>cat /proc/version - Linux的版本号相当�?uname -r
uname -a - 看系�l�内核等信息

十五、cd光盘做成iso文�g
cp /dev/cdrom xxxx.iso

十六、快速观看开机的��g��?br>dmesg | more

十七、查看硬盘的使用情况
df -k 以K为单位显�C?br>df -h 以�h性化单位昄��Q�可以是b,k,m,g,t..

十八、查看目录的大小
du -sh dirname
-s 仅显�C�总计
-h 以K、M、G为单位，提高信息的可��L��。KB、MB、GB是以1024为换��单位，-H�?000为换��单位�?/p>

十九(ji��)、查找或删除正在使用某文件的�q�程
fuser filename
fuser -k filename

二十、字�W�模式下讄��/删除环境变量
bash�?br>讄��Q�export 变量�?变量�?br>删除�Q�unset 变量�?br>csh�?br>讄��Q�setenv 变量�?变量�?br>删除�Q�unsetenv 变量�?/p>

二十一、vim中显�C�颜色或不显�C�颜�?br>vi ~/.vimrc; 如果有syntax on�Q�则昄��颜色�Q�syntax off�Q�则不显�C�颜�?/p>

二十二、修改系�l�时�?br>date -s “2003-04-14 cst”�Q�cst指时区，旉��讑֮�用date -s 18:10

二十三、开机就mount上windows下的分区
自动��windows的d盘挂�?mnt/d上，用vi打开/etc/fstab�Q�加入以下一�?br>/dev/hda5 /mnt/d vfat defaults,codepage=936,iocharset=cp936 0 0
注意�Q�先得手工徏立一�?mnt/d目录

二十四、在多��目录中查找某个文件的�Ҏ(gu��)��
find /dir -name filename.ext
du -a | grep filename.ext
locate filename.ext

二十五、不让普通用戯��己改密码
[root@xin_fc etc]# chmod 511 /usr/bin/passwd
又想让普通用戯��己改密码
[root@xin_fc etc]# chmod 4511 /usr/bin/passwd

二十六、用dd做iso
dd if=/dev/cdrom of=/tmp/aaa.iso

二十七、让Linux自动同步旉��
vi /etc/crontab
加上一�?br>00 0 1 * * root rdate -s time.nist.gov

二十八、ssh上来能不能不自动断线
那是timetou的设�|�，修改TMOUT变量�?/p>

二十�?ji��)、监视所有通过本机�|�卡的数�?br>tcpdump iptraf

megax 2008-03-11 14:12 发表评论

megax — Tue, 11 Mar 2008 06:10:00 GMT

�?如何更改 WSAD 的界面语�U?/strong>

更改 WSAD 安装目录�?wsappdev.ini 在行 VMArgs=-Xj9 后加入，为空则与操作�pȝ��默认语言相同�?br>VMArgs=-Xj9 -Duser.language=en -Duser.region=US
其他语言参数�Q?br>-Duser.language=en -Duser.region=US 【英文�?br>-Duser.language=zh -Duser.region=CN 【中文简体�?br>-Duser.language=zh -Duser.region=TW 【中文繁体�?br>

�?WebSphere Studio Application Developer 5版本中如何更攚w��认的工作�?/font>

在默认情况下�Q�WebSphere Application Developer 5在启动的时候会弹出一个提�C�窗口让用户选择 workspace。如果，用户选中了窗口下方的“��此工作�I�间用作�~�省值�ƈ且不再显�C�此对话�?#8221;�Q�那么下一�ơ客户再�q�行WSAD的时候将不会弹出提示�H�口让用户选择工作区。如果，用户再想更换工作区将无法�q�行。在 Eclipse 3.1 中，File 菜单下有 Switch Workspace 的选项�Q�但�?WSAD 5 是基�?Eclipse 2.x 的，我尝试了很久都没有找到在选项中更�?workspace 的地斏V��之后在�|�上��索，查到�q�个问题有如下解��x��案：
�Ҏ(gu��)��一�Q�用命��o行方式启动�ƈ指定所用的工作�?/p>
1. 打开命��o行窗口，�q�入wsappdev.exe所在的目录(wsappdev.exe应该在WSAD的安装�\径下)

2. 执行命��o�Q�wsappdev.exe -data �Q�其�?workdirectory>是需要��用的工作区目录。假设要指定的工作区路径为C:\ workbentch,那么命��o��应该写成：wsappdev.exe -data C:\workbentch

�Ҏ(gu��)��二：用命令行方式启动�q�弹出提�C�窗口让用户选择工作�?/p>
1. 打开命��o行窗口，�q�入wsappdev.exe所在的目录

2. 执行命��o�Q�wsappdev.exe -setworkspace

�Ҏ(gu��)��三：通过更改配置文�g让WSAD启动的时候弹��Z��个提�C�窗口让用户选择工作�?/p>
1. 用文本编辑器打开wsappdev.ini文�g(wsappdev.ini文�g和wsappdev.exe文�g在相同的路径�?,默认情况下可以看到类似如下的内容�Q?/p>
[Settings]

DefaultWorkspace=\IBM\wsappdev51\workspace

ProductName=IBM WebSphere Studio Application Developer

Version=5.1.1

Full=Yes

KeyName=wsappdev510

VMArgs=-Xj9

LUMProductID=1

LUMProductVersion=5.1.1

Website=www.ibm.com/websphere/developer/zones/studio/appdev/

[Environment Variables]

2. �?[Environment Variables] 的上�Ҏ(gu��)��加一�?SetWorkSpace=true �Q�保�?wsappdev.ini 文�g�?/p>
3. 关闭 wsappdev.ini 文�g�Q�通过菜单或者直接双�?wsappdev.exe 文�g再次启动 WSAD 的时候，��׃��弹出一个提�C�窗口让用户选择工作区�?/p>
○在 eclipse 的快��h��式后面加一�?参数:-nl “zh_US”,��可以找回英文的界面�Q�加参数�Q?nl “zh_CN” �Q�就可以用到中文界面

megax 2008-03-11 14:10 发表评论

[转]AWK说明

megax — Tue, 11 Mar 2008 06:08:00 GMT

IBM参考文章：http://www-128.ibm.com/developerworks/cn/linux/shell/awk/awk-1/index.html

AWK是一�U�优良的文本处理工具。它不仅�?Linux 中也是�Q何环境中现有的功能最强大的数据处理发动机之一。这�U�编�E�及数据操作语言�Q�其名称得自于它的创始�h Alfred Aho 、Peter Weinberger �?Brian Kernighan 姓氏的首个字母）的最大功能取决于一个�h所拥有的知识�?AWK 提供了极其强大的功能�Q�可以进行样式装入、流控制、数学运��符、进�E�控制语句甚至于内置的变量和函数。它具备了一个完整的语言所应具有的几乎所有精��特性。实际上 AWK 的确拥有自己的语�a��Q?AWK �E�序设计语言�Q�三位创��已��它正式定义�?#8220;样式扫描和处理语�a�”。它允许�(zh��n)�创建简短的�E�序�Q�这些程序读取输入文件、�ؓ数据排序、处理数据、对输入执行计算以及生成报表�Q�还有无数其他的功能�?/p>

      你可能对UNIX比较熟�?zh��n)��Q�但你可能对awk很陌生，�q�一点也不奇怪，的确�Q�与其优�U�的功能相比，awk�q�远没达到它应有的知名度。awk是什么？与其它大多数UNIX命��o不同的是�Q�从名字上看�Q�我们不可能知道awk的功能：它既不是��h��独立意义的英文单词，也不是几个相兛_��词的�~�写。事实上�Q�awk是三个�h名的�~�写�Q�他们是�Q�Aho�?Peter)Weinberg�?(Brain)Kernighan。正是这三个人创造了awk—一个优�U�的样式扫描与处理工具�?/p>
　　最��单地��_�� AWK 是一�U�用于处理文本的�~�程语言工具。AWK 在很多方面类��g�� shell �~�程语言�Q�尽��?AWK ��h��完全属于其本�w�的语法。它的设计思想来源�?SNOBOL4 、sed 、Marc Rochkind设计的有效性语�a�、语�a�工具 yacc �?lex �Q�当然还�?C 语言中获取了一些优�U�的思想。在最初创�?AWK �Ӟ��其目的是用于文本处理�Q��ƈ且这�U�语�a�的基��是，只要在输入数据中有模式匹配，��执行一�p�d��指��o。该实用工具扫描文�g中的每一行，查找与命令行中所�l�定内容相匹配的模式。如果发现匹配内容，则进行下一个编�E�步骤。如果找不到匚w��内容�Q�则�l�箋处理下一行�?/p>
　　��管操作可能会很复杂�Q�但命��o的语法始�l�是�Q?/p>
　　awk ‘{pattern + action}’ {filenames}

　　其中 pattern 表示 AWK 在数据中查找的内容，�?action 是在扑ֈ�匚w��内容时所执行的一�p�d��命��o。花括号 ({}) 不需要在�E�序中始�l�出玎ͼ�但它们用于根据特定的模式对一�p�d��指��o�q�行分组�?/p>
　　gawk �?AWK �?GNU 版本�?/p>
一、AWK的功能是什么？

      与sed�?grep很相��|��awk是一�U�样式扫描与处理工具。但其功能却大大��Z��sed和grep。awk提供了极其强大的功能�Q�它几乎可以完成grep和sed所能完成的全部工作�Q�同�Ӟ��它还可以可以�q�行样式装入、流控制、数学运��符、进�E�控制语句甚至于内置的变量和函数。它具备了一个完整的语言所应具有的几乎所有精��特性。实际上�Q�awk的确拥有自己的语�a��Q�awk�E�序设计语言�Q�awk的三位创��已��它正式定义为：样式扫描和处理语�a��?/p>
二、�ؓ什么��用awk?

      即��如此�Q�你也许仍然会问�Q�我��Z��么要使用awk?

      使用awk的第一个理由是��Z��文本的样式扫描和处理是我们经常做的工作，awk所做的工作有些象数据库�Q�但与数据库不同的是�Q�它处理的是文本文�g�Q�这些文件没有专门的存储格式�Q�普通的��Z��p��~�辑、阅诅R��理解和处理它们。而数据库文�g往往��h��Ҏ(gu��)��的存储格式，�q��得它们必��ȝ��数据库处理程序来处理它们。既然这�U�类��g��数据库的处理工作我们�l�常会遇刎ͼ�我们��应当找到处理它们的��便易行的�Ҏ(gu��)��Q�UNIX有很多这斚w��的工��P��例如sed 、grep、sort以及find�{�等�Q�awk是其中十分优�U�的一�U��?/p>
      使用awk的第二个理由是awk是一个简单的工具�Q�当然这是相对于其强大的功能来说的。的��，UNIX有许多优�U�的工��P��例如UNIX天然的开发工具C语言及其延箋C++��非常的优秀。但相对于它们来��_��awk完成同样的功能要方便和简捷得多。这首先是因为awk提供了适应多种需要的解决�Ҏ(gu��)��Q�从解决��单问题的awk命��o行到复杂而精巧的awk�E�序设计语言�Q�这样做的好处是�Q�你可以不必用复杂的�Ҏ(gu��)��去解��x��来很��单的问题。例如，你可以用一个命令行解决��单的问题�Q�而C不行�Q�即使一个再��单的�E�序�Q�C语言也必��ȝ��q�编写、编译的全过�E�。其�ơ，awk本��n是解释执行的�Q�这��׃��得awk�E�序不必�l�过�~�译的过�E�，同时�Q�这也��得它与shell script�E�序能够很好的契合。最后，awk本��n较C语言��单，虽然awk吸收了C语言很多优秀的成分，熟�?zh��n)�C语言会对学习awk有很大的帮助�Q�但 awk本��n不须要会使用C语言——一�U�功能强大但需要大量时间学习才能掌握其技巧的开发工兗��?/p>
       使用awk的第三个理由是awk是一个容易获得的工具。与C和C++语言不同�Q�awk只有一个文�?/bin/awk)�Q�而且几乎每个版本的UNIX都提供各自版本的awk�Q�你完全不必费心��L��如何获得awk。但C语言却不是这��P��虽然C语言是UNIX天然的开发工��P��但这个开发工具却是单独发行的�Q�换�a�之，你必��Mؓ你的UNIX版本的C语言开发工具单独付费（当然使用D版者除外）�Q�获得�ƈ安装它，然后你才可以使用它�?/p>
      ��Z��以上理由�Q�再加上awk强大的功能，我们有理��p��Q�如果你要处理与文本样式扫描相关的工作，awk应该是你的第一选择。在�q�里有一个可遵��@的一般原则：如果你用普通的shell工具或shell script有困隄��话，试试awk,如果awk仍不能解决问题，则便用C语言�Q�如果C语言仍然��p�|�Q�则�U�至C++�?/p>
三、awk的调用方�?/p>
      前面曄��说过�Q�awk提供了适应多种需要的不同解决�Ҏ(gu��)��Q�它们是�Q?/p>
      1�?awk命��o行，你可以象使用普通UNIX命��o一样��用awk�Q�在命��o行中你也可以使用awk�E�序设计语言�Q�虽然awk支持多行的录入，但是录入镉K��的命令行�q�保证其正确无误却是一件��o人头疼的事，因此�Q�这�U�方法一般只用于解决��单的问题。当�Ӟ��你也可以在shell script�E�序中引用awk命��o行甚至awk�E�序脚本�?/p>
      2、��?f选项调用awk�E�序。awk允许��一�D�awk�E�序写入一个文本文�Ӟ��然后在awk命��o行中�?f选项调用�q�执行这�D늨�序。具体的�Ҏ(gu��)��我们��在后面的awk语法中讲到�?/p>
      3、利用命令解释器调用awk�E�序�Q�利用UNIX支持的命令解释器功能�Q�我们可以将一�D�awk�E�序写入文本文�g�Q�然后在它的�W�一行加�?
#!/bin/awk -f
�q�赋予这个文本文件以执行的权限。这样做之后�Q�你��可以在命��o行中用类��g��下面�q�样的方式调用�ƈ执行�q�段awk�E�序了�?/p>
$awk脚本文本�?待处理文�?/p>
awk的语法：

与其它UNIX命��o一��P��awk拥有自己的语法：

awk [ -F re] [parameter…] [’prog’] [-f progfile][in_file…]

参数说明�Q?/p>
-F re:允许awk更改其字�D�分隔符�?/p>
parameter: 该参数帮助�ؓ不同的变量赋倹{�?/p>
‘prog’: awk的程序语句段。这个语句段必须用单拓号�Q?#8217;�?#8217;括�v�Q�以防被shell解释。这个程序语句段的标准�Ş式�ؓ�Q?/p>
‘pattern {action}’

      其中pattern参数可以是egrep正则表达式中的�Q何一个，它可以��用语�?re/再加上一些样式匹配技巧构成。与sed�c�M��Q�你也可以��?#8221;,”分开两样式以选择某个范围。关于匹配的�l�节�Q�你可以参考附录，如果仍不懂的话，找本UNIX书学学grep和sed�Q�本人是在学习ed时掌握匹配技术的�Q��?action参数��L��被大括号包围�Q�它�׃��pȝ��awk语句�l�成�Q�各语句之间�?#8221;;”分隔。awk解释它们�Q��ƈ在pattern�l�定的样式匹配的记录上执行其操作。与shell�c�M��Q�你也可以��?#8220;#”作�ؓ注释�W�，它��“#”到行��内容成�ؓ注释�Q�在解释执行�Ӟ��它们��被忽略。你可以省略pattern�?action之一�Q�但不能两者同时省略，当省略pattern时没有样式匹配，表示�Ҏ(gu��)��有行�Q�记录）均执行操作，省略action时执行缺省的操作——在标准输出上显�C��?/p>
      -f progfile:允许awk调用�q�执行progfile指定有程序文件。progfile是一个文本文�Ӟ��他必��ȝ��合awk的语法�?/p>
      in_file:awk的输入文�Ӟ��awk允许对多个输入文件进行处理。值得注意的是awk不修改输入文件。如果未指定输入文�g�Q�awk��接受标准输入，�q�将�l�果昄��在标准输��Z��。awk支持输入输出重定向�?/p>
      awk的记录、字�D�与内置变量�Q?/p>
      前面说过�Q�awk处理的工作与数据库的处理方式有相同之处，其相同处之一��是awk支持对记录和字段的处理，其中对字�D늚�处理是grep和sed不能实现的，�q�也是awk优于二者的原因之一。在awk中，�~�省的情况下��L��文本文件中的一行视��Z��个记录，而将一行中的某一部分作�ؓ记录中的一个字�D�c��ؓ了操作这些不同的字段�Q�awk借用shell的方法，�?1,$2,$3…�q�样的方式来��序地表�C��Q�记录）中的不同字段。特�D�地�Q�awk�?0表示整个行（记录�Q�。不同的字段之间是用�U�C��分隔�W�的字符分隔开的。系�l�默认的分隔�W�是�I�格。awk允许在命令行中用-F re的�Ş式来改变�q�个分隔�W�。事实上�Q�awk用一个内�|�的变量FS来记忆这个分隔符。awk中有好几个这��L��内置变量�Q�例如，记录分隔�W�变量RS、当前工作的记录数NR�{�等�Q�本文后面的附表列出了全部的内置变量。这些内�|�的变量可以在awk�E�序中引用或修改�Q�例如，你可以利用NR变量在模式匹配中指定工作范围�Q�也可以通过修改记录分隔�W�RS让一个特�D�字�W�而不是换行符作�ؓ记录的分隔符�?/p>
      �?昄��文本文�gmyfile中第七行到第十五行中以字�W?分隔的第一字段�Q�第三字�D�和�W�七字段�Q?/p>
awk -F % ‘NR==7,NR==15 {printf $1 $3 $7}’

四、awk的内�|�函�?/p>
      awk 之所以成��Z��U�优�U�的程序设计语�a�的原因之一是它吸收了某些优�U�的程序设计语�a��Q�例如C�Q�语�a�的许多优炏V��这些优点之一��是内置函数的��用，awk定义�q�支持了一�p�d��的内�|�函敎ͼ��׃��q�些函数的��用，使得awk提供的功能更为完善和强大�Q�例如，awk使用了一�p�d��的字�W�串处理内置函数(�q�些函数看�v来与C 语言的字�W�串处理函数�怼��Q�其使用方式与C语言中的函数也相差无�?�Q�正是由于这些内�|�函数的使用�Q��awk处理字符串的功能更加强大。本文后面的附录中列有一般的awk所提供的内�|�函敎ͼ��q�些内置函数也许与你的awk版本有些出入�Q�因此，在��用之前，最好参考一下你的系�l�中的联机帮助�?/p>
      作�ؓ内置函数的一个例子，我们��在�q�里介绍awk的printf函数�Q�这个函��C��得awk与c语言的输出相一致。实际上�Q�awk中有许多引用形式都是从C语言借用�q�来的。如果你熟�?zh��n)�C语言�Q�你也许会记得其中的printf函数�Q�它提供的强大格式输出功能曾�l�带我们许多的方�ѝ��幸�q�的是，我们在awk中又和它重逢了。awk中printf几乎与C语言中一模一��P��如果你熟�(zh��n)�C语言的话�Q�你完全可以照C语言的模式��用awk中的printf。因此在�q�里�Q�我们只�l�出一个例子，如果你不熟�?zh��n)�的话�Q�请随便找一本C语言的入门书��ȝ��?/p>
�?昄��文�gmyfile中的行号和第3字段�Q?/p>
$awk ‘{printf”%03d%sn”,NR,$1}’ myfile

五、在命��o行��用awk

      按照��序�Q�我们应当讲解awk�E�序设计的内容了�Q�但在讲解之前，我们��用一些例子来对前面的知识�q�行回顾�Q�这些例子都是在命��o行中使用的，由此我们可以知道在命令行中��用awk是多么的方便。这样做的原因一斚w��是�ؓ下面的内容作铺垫�Q�另一斚w��是介�l�一些解决简单问题的�Ҏ(gu��)��Q�我们完全没有必要用复杂的方法来解决��单的问题�?既然awk提供了较为简单的�Ҏ(gu��)��的话�?/p>
例：昄��文本文�gmydoc匚w��Q�含有）字符�?#8221;sun”的所有行�?/p>
$awk ‘/sun/{print}’ mydoc

      �׃��昄��整个记录�Q�全行）是awk的缺省动作，因此可以省略action��V�?/p>
$awk ‘/sun/’ mydoc

例：下面是一个较为复杂的匚w��的示例：

$awk ‘/[Ss]un/,/[Mm]oon/ {print}’ myfile

      它将昄��W�一个匹配Sun或sun的行与第一个匹配Moon或moon的行之间的行�Q��ƈ昄��到标准输��Z��?/p>
例：下面的示例显�C�Z��内置变量和内�|�函数l(f��)ength�Q�）的��用：

$awk ‘length($0)>80 {print NR}’ myfile

      该命令行��显�C�文本myfile中所有超�q?0个字�W�的行号�Q�在�q�里�Q�用$0表示整个记录�Q�行�Q�，同时�Q�内�|�变量NR不��用标志符’$'�?/p>
例：作�ؓ一个较为实际的例子�Q�我们假设要对UNIX中的用户�q�行安全性检查，�Ҏ(gu��)��是考察/etc下的passwd文�g�Q�检查其中的passwd字段�Q�第二字�D�）是否�?#8221;*”�Q�如不�ؓ”*”�Q�则表示该用��h��有设�|�密码，昄��些用户名�Q�第一字段�Q�。我们可以用如下语句实现�Q?/p>
#awk -F: ‘$2==”" {printf(”%s no password!n”,$1′ /etc/passwd

      在这个示例中�Q�passwd文�g的字�D�分隔符�?#8220;�Q?#8221;�Q�因此，必须�?F�Q�来更改默认的字�D�分隔符�Q�这个示例中也涉及到了内�|�函数printf的��用�?/p>
六、awk的变�?/p>
      如同其它�E�序设计语言一��P��awk允许在程序语�a�中设�|�变量，事实上，提供变量的功能是�E�序设计语言的其本要求，不提供变量的�E�序设计语言本�h�q�从未见�q��?/p>
      awk 提供两种变量�Q�一�U�是awk内置的变量，�q�前面我们已�l�讲�q�，需要着重指出的是，与后面提到的其它变量不同的是�Q�在awk�E�序中引用内�|�变量不需要��用标志符”$”�Q�回忆一下前面讲�q�的NR的��用）。awk提供的另一�U�变量是自定义变量。awk允许用户在awk�E�序语句中定义�ƈ调用自已的变量。当然这�U�变量不能与内置变量及其它awk保留字相同，在awk中引用自定义变量必须在它前面加上标志�W?#8221;$”。与C语言不同的是�Q�awk中不需要对变量�q�行初始化， awk�Ҏ(gu��)��其在awk中第一�ơ出现的形式和上下文��定其具体的数据�c�d��。当变量�c�d��不确定时�Q�awk默认其�ؓ字符串类型。这里有一个技巧：如果你要让你�?awk�E�序知道你所使用的变量的明确�c�d��Q�你应当在在�E�序中给它赋初倹{��在后面的实例中�Q�我们将用到�q�一技巧�?/p>
七、运��与判断

      作�ؓ一�U�程序设计语�a�所应具有的特点之一�Q�awk支持多种�q�算�Q�这些运��与C语言提供的几本相同：�?�?�?�?�?�{�等�Q�同�Ӟ��awk也支持C语言中类�?+�?#8211;�?=�?=�?+�?-之类的功能，�q�给熟�?zh��n)�C语言的��用者编写awk�E�序带来了极大的方便。作为对�q�算功能的一�U�扩展，awk�q�提供了一�p�d��内置的运��函敎ͼ�如log、sqr、cos、sin�{�等�Q�和一些用于对字符串进行操作（�q�算�Q�的函数�Q�如length、substr�{�等�Q�。这些函数的引用大大的提高了awk的运��功能�?/p>
      作�ؓ�Ҏ(gu��)��件�{�U�L��令的一部分�Q�关�p�d��断是每种�E�序设计语言都具备的功能�Q�awk也不例外�?awk中允许进行多�U�测试，如常用的==�Q�等于）、！=�Q�不�{�于�Q��?gt;�Q�大于）�?lt;�Q�小于）�?gt;=�Q�大于等于）�?gt;=�Q�小于等于）�{�等�Q�同�Ӟ��作�ؓ样式匚w��Q�还提供了~�Q�匹配于�Q�和�Q�~�Q�不匚w��于）判断�?/p>
       作�ؓ�Ҏ(gu��)��试的一�U�扩充，awk也支持用逻辑�q�算�W?!(�?�?amp;&�Q�与�Q�、||�Q�或�Q�和括号�Q�）�q�行多重判断�Q�这大大增强了awk的功能。本文的附录中列��Z��awk所允许的运��、判断以及操作符的优先��?/p>
八、awk的流�E�控�?/p>
      ��程控制语句是�Q何程序设计语�a�都不能缺��的部分。�Q何好的语�a�都有一些执行流�E�控制的语句。awk提供的完备的��程控制语句�c�M��于C语言�Q�这�l�我们编�E�带来了极大的方�ѝ�?/p>
1、BEGIN和END:

      在awk 中两个特别的表达式，BEGIN和END�Q�这两者都可用于pattern中（参考前面的awk语法�Q�，提供BEGIN和END的作用是�l�程序赋予初始状态和在程序结束之后执行一些扫��工作。�Q何在BEGIN之后列出的操作（在{}内）��在awk开始扫描输入之前执行，而END之后列出的操作将在扫描完全部的输入之后执行。因此，通常使用BEGIN来显�C�变量和预置�Q�初始化�Q�变量，使用END来输出最�l�结果�?/p>
      例：累计销售文件xs中的销售金额（假设销售金额在记录的第三字�D�）�Q?/p>
$awk
>’BEGIN { FS=”:”;print “�l�计销售金�?#8221;;total=0}
>{print $3;total=total+$3;}
>END {printf “销售金额总计�Q?.2f”,total}’ sx
�Q�注�Q?gt;是shell提供的第二提�C�符�Q�如要在shell�E�序awk语句和awk语言中换行，则需在行��֊�反斜杠）

      在这里，BEGIN预置了内部变量FS�Q�字�D�分隔符�Q�和自定义变量total,同时在扫描之前显�C�出输出行头。而END则在扫描完成后打印出��d��计�?/p>
      2、流�E�控制语�?/p>
      awk提供了完备的��程控制语句�Q�其用法与C语言�c�M��。下面我们一一加以说明�Q?/p>
2.1、if…else语句:

格式�Q?br>if(表达�?
语句1
else
语句2

格式�?#8221;语句1″可以是多个语句，如果你�ؓ了方便awk判断也方便你自已阅读�Q�你最好将多个语句用{}括�v来。awk分枝�l�构允许嵌套�Q�其格式为：

if(表达�?�Q?br>{if(表达�?�Q?br>语句1
else
语句2
}
语句3
else {if(表达�?)
语句4
else
语句5
}
语句6

当然实际操作�q�程中你可能不会用到如此复杂的分枝结构，�q�里只是��Z��l�出其样式�Ş了�?/p>
2.2、while语句

格式�?

while(表达�?
语句

2.3、do-while语句

格式�?

do
{
语句
}while(条�g判断语句�Q?/p>
2.4、for语句

格式为：

for(初始表达�?�l�止条�g;步长表达�?
{语句}

      在awk �?while、do-while和for语句中允�怋�用break,continue语句来控制流�E�走向，也允�怋�用exit�q�样的语句来退出。break 中断当前正在执行的��@环�ƈ跛_��循环外执行下一条语句。continue从当前位�|�蟩到��@环开始处执行。对于exit的执行有两种情况�Q�当exit语句不在 END中时�Q��Q何操作中的exit命��o表现得如同到了文件尾�Q�所有模式或操作执行��停止，END模式中的操作被执行。而出现在END中的exit��导致程序终止�?/p>
例：��Z��

�?ji��)、awk中的自定义函�?/p>
      定义和调用用戯��q��函数是几乎每个高�U�语�a�都具有的功能�Q�awk也不例外�Q�但原始的awk�q�不提供函数功能�Q�只有在nawk或较新的awk版本中才可以增加函数�?/p>
函数的��用包含两部分�Q�函数的定义与函数调用。其中函数定义又包括要执行的代码�Q�函数本�w�）和从�ȝ��序代码传递到该函数的临时调用�?/p>
awk函数的定义方法如下：

function 函数�?参数�?{
函数�?br>}

      在gawk中允许将function省略为func�Q�但其它版本的awk不允许。函数名必须是一个合法的标志�W�，参数表中可以不提供参敎ͼ�但在调用函数时函数名后的一�Ҏ(gu��)��号仍然是不可�~�少的）�Q�也可以提供一个或多个参数。与C语言�怼��Q�awk的参��C��是通过值来传递的�?/p>
      在awk 中调用函数比较简单，其方法与C语言�怼��Q�但awk比C语言更�ؓ灉|��Q�它不执行参数有效性检查。换句话��_��在你调用函数�Ӟ��可以列出比函数预计（函数定义中规定）的多或少的参敎ͼ�多余的参��C��被awk所忽略�Q�而不��的参数�Q�awk��它们置为缺省�?或空字符�Ԍ��具体�|��ؓ何��|��取决于参数的��用方式�?/p>
      awk函数有两�U�返回方式：隐式�q�回和显式返回。当awk执行到函数的�l�尾�Ӟ��它自动地�q�回到调用程序，�q�是函数是隐式返回的。如果需要在�l�束之前退出函敎ͼ�可以明确��C��用返回语句提前退出。方法是在函��C��使用形如�Q�return �q�回�?格式的语句�?/p>
      例：下面的例子演�C�Z��函数的��用。在�q�个�C�Z��中，定义了一个名为print_header的函敎ͼ�该函数调用了两个参数FileName和PageNum�Q?FileName参数传给函数当前使用的文件名�Q�PageNum参数是当前页的页受��这个函数的功能是打华ͼ�昄��Q�出当前文�g的文件名�Q�和当前��늚��号。完成这个功能后�Q�这个函数将�q�回下一��늚��号�?/p>
nawk
>’BEGIN{pageno=1;file=FILENAME
>pageno=print_header(file�Q�pageno)�Q?调用函数print_header
>printf(”当前��页��h��Q?dn”,pageno);
>}

>#定义函数print_header
>function print_header(FileName,PageNum){
>printf(”%s %dn”,FileName,PageNum); >PageNum++;return PageNUm;
>}
>}’ myfile

      执行�q�个�E�序��显�C�如下内容：

myfile 1
当前��页��h��Q?

十、awk高��输入输出

      1.��d��下一条记录：

      awk的next语句��D��awk��d��下一个记录�ƈ完成模式匚w��Q�然后立��x��行相应的操作。通常它用匚w��的模式执行操作中的代码。next��D��q�个记录的�Q何额外匹配模式被忽略�?/p>
      2.��单地��d��一条记�?/p>
      awk �?getline语句用于��单地��d��一条记录。如果用��h��一个数据记录类��g��个物理记录，那么getline��尤其有用。它完成一般字�D늚�分离(讄��字段变量$0 FNR NF NR)。如果成功则�q�回1�Q�失败则�q�回0�Q�到达文件尾�Q�。如果需��单地��d��一个文�Ӟ��则可以编写以下代码：

例：�C�Z��getline的��?/p>
{while(getline==1)
{
#process the inputted fields
}
}

      也可以��getline保存输入数据在一个字�D�中�Q�而不是通过使用getline variable的�Ş式处理一般字�D�c��当使用�q�种方式�Ӟ��NF被置�?�Q�FNR和NR被增倹{�?/p>
      用户也可以��用getline<"filename"方式从一个给定的文�g中输入数据，而不是从命��o行所列内容输入数据。此�Ӟ��getline��完成一般字�D�分��（讄��字段变量$0和NF)。如果文件不存在�Q�返�?1,成功�Q�返�?,�q�回0表示��p�|。用户可以从�l�定文�g中读取数据到一个变量中�Q�也可以用stdin(标准输入讑֤��Q�或一个包含这个文件名的变量代替filename。值得注意的是当��用这�U�方式时不修改FNR和NR�?/p>
      另一�U��用getline语句的方法是从UNIX命��o接受输入�Q�例如下面的例子:

例：�C�Z��从UNIX命��o接受输入

{while("who -u"|getline)
{
#process each line from the who command
}
}

当然�Q�也可以使用如下形式:

"command" | getline variable

      3.关闭文�g:

      awk中允许在�E�序中关闭一个输入或输出文�g�Q�方法是使用awk的close语句�?/p>
close("filename"t

      filename可以是getline打开的文�Ӟ��也可以是stdin,包含文�g名的变量或者getline使用的确切命令）。或一个输出文�Ӟ��可以是stdout�Q�包含文件名的变量或使用��道的确切命令）�?/p>
      4.输出��C��个文�?

awk中允许用如下方式��结果输出到一个文�Ӟ��

printf("hello word!n"t>“datafile”
�?br>printf(”hello word!n”t>>”datafile”

      5.输出��C��个命�?/p>
awk中允许用如下方式��结果输出到一个命令：

printf(”hello word!n”t|”sort-t’,'”

十一、awk与shell script混合�~�程

      因�ؓawk可以作�ؓ一个shell命��o使用�Q�因此awk能与shell批处理程序很好的融合在一��P��q�给实现awk与shell�E�序的�؜合编�E�提供了可能。实现�؜合编�E�的关键是awk与shell script之间的对话，换言之，��是awk与shell script之间的信息交��?awk从shell script中获取所需的信息（通常是变量的��|��、在awk中执行shell命��o行、shell script��命令执行的�l�果送给awk处理以及shell script��d��awk的执行结果等�{��?/p>
1.awk��d��Shell script�E�序变量

在awk中我们可以通过“’$变量�?#8217;”的方式读取sell scrpit�E�序中的变量�?/p>
例：在下面的�C�Z��中，我们��读取sell scrpit�E�序中的变量Name�Q�该变量存放的是文本myfile的撰写者，awk��打印出�q�个人名�?/p>
$cat writename
:
# @(#)
#
.
.
.
Name=”张三” nawk ‘BEGIN {name=”‘Name’”; printf(”t%st撰写�?sn”,FILENAME,name”t;}
{…}END{…}’ myfile
.
.
.

2.��shell命��o的执行结果送给awk处理

作�ؓ信息传送的一�U�方法，我们可以��一条shell命��o的结果通过��道�U�（|�Q�传递给awk处理�Q?/p>
例：�C�Z��awk处理shell命��o的执行结�?/p>
$who -u | awk ‘{printf(”%s正在执行%sn”,$2,$1)}’

该命令将打印出注册终端正在执行的�E�序名�?/p>
3.shell script�E�序读awk的执行结�?/p>
��Z��实现shell script�E�序��d��awk执行的结果，我们可以采取一些特�D�的�Ҏ(gu��)��Q�例如我们可以用变量�?`awk语句`的�Ş式将awk执行的结果存攑օ�一�?shell script变量。当然也可以用管道线的方法将awk执行�l�果传递给shell script�E�序处理�?/p>
例：作�ؓ传送消息的机制之一�Q�UNIX提供了一个向其所有用户传送消息的命��owall�Q�意思是write to all写给所有用��P��Q�该命��o允许向所有工作中的用��P��l�端�Q�发送消息。�ؓ此，我们可以通过一�D�shell批处理程序wall.shell来模拟这一�E�序�Q�事实上比较老的版本中wall��是一�D�shell批处理程序：

$cat wall.shell
:
# @(#) wall.shell:发送消息给每个已注册终�?br>#
cat >/tmp/$$
#用户录入消息文本 who -u | awk ‘{print $2}’ | while read tty
do
cat /tmp/$$>$tty
done

在这个程序里�Q�awk接受who -u命��o的执行结果，该命令打印出所有已注册�l�端的信息，其中�W�二个字�D�|��已注册终端的讑֤�名，因此用awk命��o析出该设备名�Q�然后用while read tty语句循环��d��q�些文�g名到变量�Q�shell script变量�Q�tty中，作�ؓ信息传送的�l�结地址�?/p>
4.在awk中执行shell命��o行�?嵌入函数system()

system()是一个不适合字符或数字类型的嵌入函数�Q�该函数的功能是处理作�ؓ参数传递给它的字符丌Ӏ�system对这个参数的处理��是��其作�ؓ命��o处理�Q�也��是说将其当作命令行一样加以执行。这使得用户在自��q��awk�E�序需要时可以灉|��地执行命令或脚本�?/p>
例：下面的程序将使用system嵌入函数打印用户�~�制好的报表文�g�Q�这个文件存攑֜�名�ؓmyreport.txt的文件中。�ؓ��U��v见，我们只列��Z��其END部分�Q?/p>
.
.
.
END {close(”myreport.txt”t;system(”lp myreport.txt”t;}

在这个示例中�Q�我们首先��用close语句关闭了文件myreport.txt文�g�Q�然后��用system嵌入函数��myreport.txt送入打印机打印�?/p>
写到�q�里�Q�我不得不跟朋友们说再见了，实在地说�Q�这些内容仍然是awk的初步知识，�?sh��)脑永远是前�q�的�U�学�Q�awk也不例外�Q�本��所能做的只是在你前行的漫�O镉K��中铺��^一�D�小��开端，剩下的�\�q�得靠你自己去走。老实��_��如果本文真能�l�你前行的�\上带来些许的方便�Q�那本�h��q��了�Q?/p>
如对本篇有�Q何疑问，请E-mail To:Chizlong@yeah.net或到主页http://chizling.yeah.net中留�a��?br>附录�Q?/p>
1.awk的常规表辑ּ�元字�W?/p>
换码序列
^ 在字�W�串的开头开始匹�?br>$ 在字�W�串的结��ּ�始匹�?br>. 与�Q何单个字�W�串匚w��
[ABC] 与[]内的��M��字符匚w��
[A-Ca-c] 与A-C及a-c范围内的字符匚w��Q�按字母表顺序）
[^ABC] 与除[]内的所有字�W�以外的��M��字符匚w��
Desk|Chair 与Desk和Chair中的��M��个匹�?br>[ABC][DEF] 兌��。与A、B、C中的��M��字符匚w��Q�且其后要跟D、E、F中的��M��个字�W��?br>* 与A、B或C中�Q一个出�?�ơ或多次的字�W�相匚w��
+ 与A、B或C中�Q何一个出�?�ơ或多次的字�W�相匚w��
�Q?与一个空串或A、B或C在�Q何一个字�W�相匚w��
�Q�Blue|Black�Q�berry 合�ƈ常规表达式，与Blueberry或Blackberry相匹�?/p>
2.awk��术�q�算�W?/p>
�q�算�W?用�?br>—————�?br>x^y x的y�ơ幂
x**y 同上
x%y 计算x/y的余敎ͼ�求模�Q?br>x+y x加y
x-y x减y
x*y x乘y
x/y x除y
-y 负y(y的开关符�?;也称一目减
++y y�?后��用y(前置加）
y++ 使用y值后�?�Q�后�~�加）
–y y�?后��用y(前置减）
y– 使用后y�?(后缀减）
x=y ��y的��D��l�x
x+=y ��x+y的��D��l�x
x-=y ��x-y的��D��l�x
x*=y ��x*y的��D��l�x
x/=y ��x/y的��D��l�x x%=y ��x%y的��D��l�x
x^=y ��x^y的��D��l�x
x**=y ��x**y的��D��l�x

3.awk允许的测试：

操作�W?含义

x==y x�{�于y
x!=y x不等于y
x>y x大于y
x>=y x大于或等于y
xx<=y x��于或等于y?
x~re x匚w��正则表达式re?
x!~re x不匹配正则表辑ּ�re?

4.awk的操作符(按优先��升序排列)

= �?=�?-=�?*= �?= �?%=
||
&&
> >= < <= == != ~ !~
xy (字符串连�l�，’x'’y'变成”xy”�Q?br>+ -
* / %
++ –

5.awk内置变量�Q�预定义变量�Q?/p>
说明�Q�表中v��表�C�第一个支持变量的工具�Q�下同）�Q�A=awk�Q�N=nawk,P=POSIX awk,G=gawk

V 变量含义 �~�省�?br>—————————————————�?#8211;
N ARGC 命��o行参��C��?br>G ARGIND 当前被处理文件的ARGV标志�W?br>N ARGV 命��o行参数数�l?br>G CONVFMT 数字转换格式 %.6g
P ENVIRON UNIX环境变量
N ERRNO UNIX�pȝ��错误消息
G FIELDWIDTHS 输入字段宽度的空白分隔字�W�串
A FILENAME 当前输入文�g的名�?br>P FNR 当前记录�?br>A FS 输入字段分隔�W?�I�格
G IGNORECASE 控制大小写敏�?�Q�大��写敏感�Q?br>A NF 当前记录中的字段个数
A NR 已经��d��的记录数
A OFMT 数字的输出格�?%.6g
A OFS 输出字段分隔�W?�I�格
A ORS 输出的记录分隔符新行
A RS 输入的记录他隔符新行
N RSTART 被匹配函数匹配的字符串首
N RLENGTH 被匹配函数匹配的字符串长�?br>N SUBSEP 下标分隔�W?“34″

6.awk的内�|�函�?/p>
V 函数用途或�q�回�?br>———————————————�?br>N gsub(reg,string,target) 每次常规表达式reg匚w��时替换target中的string
N index(search,string) �q�回string中search串的位置
A length(string) 求串string中的字符个数
N match(string,reg) �q�回常规表达式reg匚w��的string中的位置
N printf(format,variable) 格式化输出，按format提供的格式输出变量variable�?br>N split(string,store,delim) �Ҏ(gu��)��分界�W�delim,分解string为store的数�l�元�?br>N sprintf(format,variable) �q�回一个包含基于format的格式化数据�Q�variables是要攑ֈ�串中的数�?br>G strftime(format,timestamp) �q�回一个基于format的日期或者时间串�Q�timestmp是systime()函数�q�回的时�?br>N sub(reg,string,target) �W�一�ơ当常规表达式reg匚w��Q�替换target串中的字�W�串
A substr(string,position,len) �q�回一个以position开始len个字�W�的子串
P totower(string) �q�回string中对应的��写字符
P toupper(string) �q�回string中对应的大写字符
A atan(x,y) x的余�?弧度)
N cos(x) x的余�?弧度)
A exp(x) e的x�q?br>A int(x) x的整数部�?br>A log(x) x的自然对数�?br>N rand() 0-1之间的随机数
N sin(x) x的正�?弧度)
A sqrt(x) x的��^�Ҏ(gu��)��
A srand(x) 初始化随机数发生器。如果忽略x�Q�则使用system()
G system() �q�回�?970�q?�?日以来经�q�的旉��Q�按�U�计��）

megax 2008-03-11 14:08 发表评论

[转]grep 用法

megax — Tue, 11 Mar 2008 06:07:00 GMT

�q�组命��o以指定模式搜索文�Ӟ��q��知用户在什么文件中搜烦��C��指定的模式匹配的字符�Ԍ��q�打印出所有包含该字符串的文本行，在该文本行的最前面是该行所在的文�g名�?grep 命��o一�ơ只能搜索一个指定的模式�Q�egrep 命��o��索扩展的正则表达式（包括表达式组和可选项�Q�；fgrep 命��o��索固定字�W�串�Q�它不识别正则表辑ּ��Q�是快速搜索命令�?/p>

�q�组命��o在搜索与定位文�g中特定的主题斚w��非常有用。要搜烦的模式可以被认�ؓ是一些关键词�Q��?zh��n)�可以用它们来搜烦文�g中包含的�q�些关键词。编写程序时�Q�可以用它来��L��某一个函敎ͼ�或是相关的词�l�。grep 命��o的搜索功能比 fgrep 强大�Q�因�?grep 命��o的搜索模式可以是正则表达式，�?fgrep 却不能�?/p>
该组命��o中的每一个命令都有一�l�选项�Q�利用这些选项可以改变其输出方式。例如，可以在搜索到的文本行上加入行��P��或者只输出文本行的行号�Q�或者输出所有与搜烦模式不匹配的文本行，或只��单地输出已搜索到指定模式的文件名�Q��ƈ且可以指定在查找模式时忽略大��写�?/p>
�q�组命��o在指定氖淙胛募胁檎矣肽�Q�狡ヅ涞男小�Q��Q挥兄付ㄎ募虼颖曜际�?中读取。正常情况下�Q�每个匹配的行被昄��到标准输出。如果要查找的文件是多个�Q�则在每一行输��Z��前加上文件名�?/p>
语法�Q? grep [选项] [查找模式] [文�g�?�Q�文件名2�Q?#8230;…] egrep [选项] [查找模式] [文�g�?�Q�文件名2�Q?#8230;…] fgrep [选项] [查找模式] [文�g�?�Q�文件名2�Q?#8230;…]

该命令的各选项含义如下�Q?/strong>

-E 每个模式作�ؓ一个扩展的正则表达式对待�?-F 每个模式作�ؓ一�l�固定字�W�串对待�Q�以新行分隔�Q�，而不作�ؓ正则表达式�?-b 在输出的每一行前昄��包含匚w��字符串的行在文�g中的字节偏移量�?-c 只显�C�匹配行的数量�?-i 比较时不区分大小写�?-h 在查扑֤�个文件时�Q�指�C�grep不要��文件名加入到输��Z��前�?-l 昄��首次匚w��串所在的文�g名�ƈ用换行符��其隔开�? 当在某文件中多次出现匚w��串时�Q�不重复昄��此文件名�?-n 在输出前加上匚w��串所在行的行��P��文�g首行行号�?�Q��?-v 只显�C�Z��包含匚w��串的行�?-x 只显�C�整行严格匹配的行�?-e expression 指定��索��用的模式。用于防止以“-”开头的模式被解释�ؓ命��o选项�?-f expfile 从expfile文�g中获取要搜烦的模式，一个模式占一行�?/pre>
对该�l�命令的使用�q�需注意以下斚w��Q?/p>
在命令后键入搜烦的模式，再键入要搜烦的文件。其中，文�g名列表中也可以��用特�D�字�W�，�?“*” �{�，用来生成文�g名列表。如果想在搜索的模式中包含有�I�格的字�W�串�Q�可以用单引��h��要搜索的模式括�v来，用来表明搜烦的模式是由包含空格的字符串组成。否则，Shell ��把�I�格认�ؓ是命令行参数的定界符�Q��?grep 命��o��把搜烦模式中的单词解释为文件名列表中的一部分。在下面的例子中�Q�grep 命��o在文�?example 中搜索模�?“text file”�?/p>
grep ’text file’ example

用户可以在命令行上用Shell�Ҏ(gu��)��字符来生成将要搜索的文�g名列表。在下面的例子中�Q�特�D�字�W?#8220;*”用来生成一个文件名列表�Q�该列表包含当前目录下所有的文�g。该命��o��搜索出当前目录下所有文件中与模式匹配的行�?/p>
grep data *

�Ҏ(gu��)��字符在搜索一�l�指定的文�g旉��常有用。例如，如果��x��索所有的C�E�序源文件中特定的模式，�(zh��n)�可以用“*.c”来指定文件名列表。假讄��L�� C�E�序中包含一些不必要的�{向语句（goto语句�Q�，惌��扑ֈ��q�些语句�Q�可以用如下的命令来搜烦�q�显�C�所有包�?goto语句的代码行�Q?/p>
grep goto *.c

用户可以在命令行上键入搜索模式，也可以��?-f 选项从指定文件中��d��要搜索的模式。在文�g中，每个搜烦模式占一行。如果经常要搜烦一�l�常见字�W�串�Ӟ��q�个功能非常有用。在下面的例子中�Q�用戯��在文�?exam 中搜索字�W�串 “editor” �?“create”�Q�就把要搜烦的模式放�|�在文�g mypats 中，然后�Q�grep 命��o从文�?mypats 中读取要搜烦的模式�?/p>
grep -f mypats exam

megax 2008-03-11 14:07 发表评论

[转]gawk 手册

megax — Tue, 11 Mar 2008 06:06:00 GMT

备注�Q?/p>

当把awk代码存储到文件中的时候，’是不需要的�Q�即开头和末尾均不需�?#8217;�?
一下�ؓ参考链接：
http://fanqiang.chinaunix.net/program/shell/2005-03-30/3068.shtml
http://fanqiang.chinaunix.net/program/shell/index.shtml
http://www.linuxsir.org/bbs/showthread.php?t=184399

GAWK

�W�一�?前言
�W�二�?��?br>�W�三�?��d��输入档案
�W�四�?印出
�W�五�?Patterns
�W�六�?��式(Expression)作�ؓActions的叙�q?br>�W�七�?Actions里面的控制叙�q?br>�W�八�?内徏函式(Built-in Functions)
�W�九(ji��)�?使用者定义的函式
�W�十�?□例
�W�十一�?�l�论
�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q�＝�Q?/p>
�W�一�?前言

awk 是一个程式语�a��Q�对��D��料的处理��h��很强的功能。对於文
字档里的资料做修攏V��比寏V��抽取等的处理，awk 能够以很短的�E�式
��L��地完成。如果��?C �?Pascal �{�语�a�写程式完成上�q�的动作�Q?br>会不方便且很��p��旉��Q�所写的�E�式也会很大�?/p>
awk 能够依照使用者的定义格式来分解输入资料，也可依照使用
者定义的格式来印��料�?/p>
awk 名称的由来是由它的原始设计者的姓氏之第一个字母而命�?br>�Q�Alfred V. Aho, Peter J. Weinberger, Brian W. Kernighan�?br>awk最初在1977�q�完成。一个新版本的awk�?985�q�被发表�Q�它的功�?br>比旧版本增强不少�?/p>
gawk 是GNU所做的 awk�Q�gawk 最初在1986�q�完成，之後不断�?br>被改�q�、更新。gawk 包含 awk 的所有功能�?/p>
往後的 gawk ��以下面�?个输入档案来做例子说明�?/p>
档案’BBS-list’�Q?br>aardvark 555-5553 1200/300 B
alpo-net 555-3412 2400/1200/300 A
barfly 555-7685 1200/300 A
bites 555-1675 2400/1200/300 A
camelot 555-0542 300 C
core 555-2912 1200/300 C
fooey 555-1234 2400/1200/300 B
foot 555-6699 1200/300 B
macfoo 555-6480 1200/300 A
sdace 555-3430 2400/1200/300 A
sabafoo 555-2127 1200/300 C

档案’shipped’�Q?br>Jan 13 25 15 115
Feb 15 32 24 226
Mar 15 24 34 228
Apr 31 52 63 420
May 16 34 29 208
Jun 31 42 75 492
Jul 24 34 67 436
Aug 15 34 47 316
Sep 13 55 37 277
Oct 29 54 68 525
Nov 20 87 82 577
Dec 17 35 61 401

Jan 21 36 64 620
Feb 26 58 80 652
Mar 24 75 70 495
Apr 21 70 74 514
�W�二�?��?/p>
gawk 的主要功能是针对档案的每一�?line)搜寻指定�?patterns
。当一行里有符合指定的 patterns�Q�gawk ��׃��在此一行执行被指定
�?actions�?gawk 依此方式处理输入档案的每一行直到输入档案结
束�?/p>
gawk �E�式是由很多�?pattern �?action 所�l�成�Q�action 写在
大括�?{ } 里面�Q�一个pattern後面��p��著一个action。整�?gawk �E?br>式会像下面的样子�Q?/p>
pattern {action}
pattern {action}

�?gawk �E�式里面的规则，pattern �?action 能够被省略，�?br>是两个不能同时被省略。如�?pattern 被省略，�Ҏ(gu��)��输入档里面的
每一行，action 都会被执行。如�?action 被省略，内定�?action
则会印出所有符�?pattern 的输入行�?br>2.1 如何执行gawk�E�式

基本上，�?个方法可以执行gawk�E�式�?/p>
□如�?gawk �E�式很短�Q�则 gawk 可以直接写在 command line�Q�如下所�C�：

gawk ‘program’ input-file1 input-file2 …

其中 program 包括一�?pattern �?action�?/p>
□如�?gawk �E�式较长�Q�较为方便的做法是将 gawk �E�式存在一个档案，
�?patterns �?actions 写在档名�?program-file 的档案里面，执行
gawk 的格式如下所�C�：

gawk -f program-file input-file1 input-file2 …

gawk �E�式的档案不止一个时�Q�执行gawk 的格式如下所�C�：

gawk -f program-file1 -f program-file2 … input-file1
input-file2 …
2.2 一个简单的例子

现在我们举一个简单的例子�Q�因�?gawk �E�式很短�Q�所以将 gawk �E?br>式直接写�?command line�?/p>
gawk ‘/foo/ {print $0}’ BBS-list

实际�?gawk �E�式�?/foo/ {print $0}�?foo/ �?pattern�Q�意思�ؓ�?br>寻输入档里的每一行是否含有子字串 ‘foo’�Q�如果含�?‘foo’ 则执�?action�?br>action �?print $0�Q�是��现在这一行的内容印出。BBS-list 是输入的档案�?/p>
执行完上�q�指令後�Q�会印出下面的结果：
fooey 555-1234 2400/1200/300 B
foot 555-6699 1200/300 B
macfoo 555-6480 1200/300 A
sabafoo 555-2127 1200/300 C
2.3 一个较复杂的例�?/p>
gawk ‘$1 == “Feb” {sum=$2+$3} END {print sum}’ shipped

现在�q�个例子会将输入�?’shipped’ 的第一个栏位与 “Feb” 做比�?br>�Q�如果相�{�，则其对应的第2栏位与第3栏位的��g��被加到变�?sum�?br>�Ҏ(gu��)��输入档的每一行重复上�q�的动作�Q�直到输入档的每一行都被处�?br>�q��ؓ止。最後将 sum 的值印出。END {print sum} 的意思�ؓ在所有的�?br>入读完之後，执行一��?print sum 的动作，也就是把 sum 的值印出�?/p>
下面是执行的�l�果�Q?br>84
�W�三�?��d��输入档案

gawk的输入可以从标准输入或指定的档案里读取。输入的��d��?br>位被�U�Cؓ”记录”(records)�Q�gawk 在做处理�Ӟ��是一个记录一个记
录地处理。每个记录的内定值是一�?line)�Q�一个记录又被分为多�?br>栏位(fields)�?br>3.1 如何��输入分解成记录(records)

gawk 语言会把输入分解成记�?record)。记录与记录之间是以
record separator 隔开�Q�record separator 的内定值是表示��C��行的
字元(newline character)�Q�因此内定的 record separator 使得文字
的每一行是一个记录�?/p>
record separator 随著内徏变数 RS 的改变而改变。RS 是一个字�Ԍ��
它的内定值是”\n”。仅�?RS 的第一个字元是有效的，它被当作 record
separator�Q��?RS 的其它字元会被忽略�?/p>
内徏变数 FNR 会储存目前的输入档案已经被读取的记录之个数。内
建变�?NR 会储存目前�ؓ止所有的输入档案已经被读取的记录之个数�?br>3.2 栏位(field)

gawk 会自动将每个记录分解成多个栏�?(field)。类似於字在一
行里面，gawk 的内定动作会认�ؓ栏位之间是以 whitespace 分开。在
gawk 里，whitespace 的意思是一个或多个�I�白�?tabs�?/p>
�?gawk �E�式里面�Q�以’$1′表示�W�一个栏位，’$2′表示�W�二个栏�?br>�Q�依此类推。�D个例子，假设输入的一行如下所�C�：

This seems like a pretty nice example.

�W�一个栏位或 $1 �?#8217;This’�Q�第二个栏位�?$2 �?’seems’�Q�依此类推�?br>有个地方值得特别注意�Q�第七个栏位�?$7 �?#8217;example.’而非’example’�?/p>
不论有多��栏位，$NF 可用来表�C�Z��个记录的最後一个栏位。以
上面的例子�ؓ例，$NF �?$7 相同�Q�也��是’example.’�?/p>
NF 是一个内建变敎ͼ�它的��D��C�目前这个记录之栏位的个数�?/p>
$0�Q�看��h��好像是第零个栏位�Q�它是一个特例，它表�C�整个记录�?/p>
下面是一个较复杂的例子：

gawk ‘$1~/foo/ {print $0}’ BBS-list

�l�果如下�Q?br>fooey 555-1234 2400/1200/300 B
foot 555-6699 1200/300 B
macfoo 555-6480 1200/300 A
sabafoo 555-2127 1200/300 C

�q�个例子是把输入�?#8217;BBS-list’的每个记录的�W�一个栏位作��查，�?br>果它含有子字�?#8217;foo’�Q�则�q�一个记录会被印出�?br>3.3 如何��记录分解成栏位

gawk �Ҏ(gu��)�� field separator ��一个记录分解成栏位。field sepa-
rator 以内建变�?FS 表示�?/p>
举个例子�Q�假�?field separator �?#8217;oo’�Q�则下面的行�Q?/p>
moo goo gai pan

会被分成三个栏位�Q?#8217;m'�?#8217; g’�?#8217; gai pan’�?/p>
�?gawk �E�式里，可以使用’='来改�?FS 的倹{��例�?

gawk ‘BEGIN {FS=”,”}; {print $2}’

输入行如下：

John Q. Smith, 29 Oak St., Walamazoo, MI 42139

执行gawk的结果将印出字串 ‘ 29 Oak St.’。BEGIN 後面�?action 会在
�W�一个记录被��d��之前执行一�ơ�?br>�W�四�?印出

在gawk�E�式里，actions 最常做的事��是印出(printing)。简�?br>的印出，使用 printe叙述。复杂格式的印出�Q��?printf 叙述�?br>4.1 print叙述

print 叙述用在��单、标准的输出格式。叙�q�的格式如下所�C�：

print item1, item2, …

输出�Ӟ��各个 item 之间会以一个空白分开�Q�最後会换行(newline)�?/p>
如果 ‘print’叙述之後没有跟著��M��东西�Q�它�?#8217;print $0′的效
果一��P��它会印出现在的记�?record)。要印出�I�白行可使用’print
“”‘�?印出一�D�固定的文字�Q�可用双引号��文字的两边括�v来，例如
‘print “Hello there”‘�?/p>
�q�里是一个例子，它会把每个输入记录的前二个栏位印出：

gawk ‘{print $1,$2}’ shipped

�l�果如下所�C�：
Jan 13
Feb 15
Mar 15
Apr 31
May 16
Jun 31
Jul 24
Aug 15
Sep 13
Oct 29
Nov 20
Dec 17

Jan 21
Feb 26
Mar 24
Apr 21
4.2 Output Separators

前面我们已提�q�如�?print 叙述包含有多�?item�Q�item 之间
用逗点分开�Q�则印出时各个item会被一个空白隔开。你能够使用��M��
的字串作�?output field separator�Q�可以经由内建变�?OFS 的设
定来更改 output field separator。OFS 的初始��gؓ” “�Q�即一格的
�I�白�?/p>
整个 print 叙述的输��U�Cؓ output record。print 叙述�?br>�?output record 之後�Q�会接著输出一个字�Ԍ��此字串称�?output
record separator。内建变�?ORS 用来指明此字丌Ӏ�ORS 的初始�?br>�?“\n”�Q�也��是换行�?/p>
下面�q�个例子会印出每个记录的�W�一个栏位和�W�二个栏位，此二
个栏位之间以分号’;'分开�Q�每行输��Z��後会加入一个空白行�?/p>
gawk ‘BEGIN {OFS=”;”; ORS=”\n\n”} {print $1, $2}’ BBS-list

�l�果如下所�C�：
aardvark;555-5553

alpo-net;555-3412

barfly;555-7685

bites;555-1675

camelot;555-0542

core;555-2912

fooey;555-1234

foot;555-6699

macfoo;555-6480

sdace;555-3430

sabafoo;555-2127

4.3 printf叙述

printf 叙述会��得输出格式较�Ҏ(gu��)��_��地控制。printf 叙述可以
指定每个 item 印出的宽度，也可以指定数字的各种型式�?/p>
printf 叙述的格式如下：

printf format, item1, item2, …

print �?printf 的差别是在於 format, printf 的引数比 print
多了字串 format。format 的型式与 ANSI C �?printf 之格式相同�?/p>
printf �q�不会做自动换行的动作。内建变�?OFS �?ORS �?printf �?br>�q�没有�Q何媄响�?/p>
格式的指定以字元’%'开始，後面接著格式控制字母�?/p>
格式控制字母如下所�C�：

‘c’ ��数字以 ASCII 字元印出�?br>例如’printf “%C”,65′会印出字�?#8217;A'�?/p>
‘d’ 印出十进位的整数�?/p>
‘i’ 印出十进位的整数�?/p>
‘e’ ��数字以�U�学�W�号的�Ş式印出�?br>例如

print “$4.3e”,1950

�l�果会印�?#8217;1.950e+03′�?/p>
‘f’ ��数字以��点的�Ş式印出�?/p>
‘g’ ��数字以�U�学�W�号的�Ş式或��点的�Ş式印出。数字的�l�对值如�?br>大於�{�於0.0001则以��点的�Ş式印出，否则以科学符��L��形式�?br>出�?/p>
‘o’ 印出无号的八�q�位整数�?/p>
’s’ 印出一个字丌Ӏ?/p>
‘x’ 印出无号的十六进位整数�?0�?5�?#8217;a'�?#8217;f'表示�?/p>
‘X’ 印出无号的十六进位整数�?0�?5�?#8217;A'�?#8217;F”表示�?/p>
‘%’ 它�ƈ不是真正的格式控制字母，’%%”��印�?#8221;%’�?/p>
�?% 与格式控制字母之间可加入 modifier�Q�modifier 是用来进一
步控制输出的格式。可能的 modifier 如下所�C�：

‘-’ 使用�?width 之前�Q�指明是向左靠齐。如�?#8217;-'没有出现�Q�则会在
被指定的宽度向右靠齐。例如：

printf “%-4S”, “foo”

会印�?#8217;foo ‘�?/p>
‘width’ �q�一个数字指�C�相对应的栏位印出时的宽度。例如：

printf “%4s”,”foo”

会印�?#8217; foo’�?/p>
width 的值是一个最��宽度而非最大宽度。如果一�?item �?br>值需要的宽度�?width 大，则不�?width 的媄响。例�?/p>
printf “%4s”,”foobar”

��印�?#8217;foobar’�?/p>
‘.prec’ 此数字指定印出时的精��度。它指定��数点右边的位数。如
果是要印��Z��个字�Ԍ��它指定此字串最多会被印出多��个�?br>元�?br>�W�五�?patterns

�?gawk �E�式里面�Q�当 pattern �W�合现在的输入记�?record)�Q�其
相对应的 action 才会被执行�?br>5.1 Pattern的种�c?/p>
�q�里�?gawk 的各�U?pattern 型式作一整理�Q?/p>
/regular expression/
一�?regular expression 当作一�?pattern。每当输入记�?(
record)含有 regular expression ��p��为符合�?/p>
expression
一个单一�?expression。当一个��g��?0 或一个字串不是空的，
则可视�ؓ�W�合�?/p>
pat1,pat2
一对的 patterns 以逗号分开�Q�指定记录的□围�?/p>
BEGIN
END
�q�是特别�?pattern, gawk 在开始执行或要结束时会分别执行相
对应於BEGIN或END�?action�?/p>
null
�q�是一个空的pattern�Q�对於每个输入记录皆视�ؓ�W�合pattern�?br>5.2 Regular Expressions当作Patterns

一�?regular expression 可简写�ؓ regexp�Q�是一�U�描�q�字串的�?br>法。一�?regular expression 以斜�U?’/')包围当作 gawk �?pattern�?/p>
如果输入记录含有 regexp ��p��为符合。例如：pattern �?/foo/�Q?br>�Ҏ(gu��)��M��输入记录含有’foo’则视为符合�?/p>
下面的例子会��含�?#8217;foo’的输入记录之�W?个栏位印出�?/p>
gawk ‘/foo/ {print $2}’ BBS-list

�l�果如下�Q?br>555-1234
555-6699
555-6480
555-2127

regexp 也能使用在比较的��式�?/p>
exp ~ /regexp/
如果 exp �W�合 regexp�Q�则�l�果为真(true)�?/p>
exp !~ /regexp/
如果 exp 不符�?regexp�Q�则�l�果为真�?br>5.3 比较的算式当作Patterns

比较�?pattern 用来��试两个数字或字串的关系诸如大於、等�?br>、小方{��下面列��Z��些比较的pattern�Q?/p>
x x<=y 如果 x ��於、等�?y�Q�则�l�果为真�?br>x>y 如果 x 大於 y�Q�则�l�果为真�?br>x>=y 如果 x 大於、等�?y�Q�则�l�果为真�?br>x==y 如果 x �{�於 y�Q�则�l�果为真�?br>x!=y 如果 x 不等�?y�Q�则�l�果为真�?br>x~y 如果 x �W�合 regular expression y�Q�则�l�果为真�?br>x!~y 如果 x 不符�?regular expression y�Q�则�l�果为真�?/p>
上面所提到�?x �?y�Q�如果二者皆是数字则视�ؓ数字之间的比较，
否则它们会被转换成字串且以字串的形式做比较。两个字串的比较�Q?br>会先比较�W�一个字元，然後比较�W�二个字元，依此�c�L��Q�直到有不同
的地方出��Cؓ止。如果两个字串在较短的一个结束之前是相等�Q�则�?br>为长的字串比短的字串大。例�?“10″ �?“9″ ��，”abc” �?“abcd” ��?br>5.4 使用布林�q�算的Patterns

一个布�?boolean) pattern 是��用布林运��?#8221;�?#8221;(’||’)�Q?#8221;�?#8221;
(’&&’)�Q?#8221;�?#8221;(’!')来组合其它的pattern�?br>例如�Q?/p>
gawk ‘/2400/ && /foo/’ BBS-list
gawk ‘/2400/ || /foo/’ BBS-list
gawk ‘! /foo/’ BBS-list
�W�六�?��式(Expression)作�ؓActions的叙�q?/p>
��式(Expression) 是gawk�E�式里面action的基本构成者�?br>6.1 ��术�q�算

gawk 里的��术�q�算如下所�C�：

x+y �?br>x-y �?br>-x �?br>+x 正。实际上没有��M��影响�?br>x*y �?br>x/y �?br>x%y 求馀数。例�?5%3=2�?br>x^y
x**y x �?y �ơ方。例�?^3=8�?br>6.2 比较��式与布林算�?/p>
比较��式 (comparison expression) 用来比较字串或数字的关系
�Q�运��符号与 C 语言相同。表列如下：

x x<=y
x>y
x>=y
x==y
x!=y
x~y
x!~y

比较的结果�ؓ�?true)则其值是 1。否则其值是 0�?/p>
布林��式(boolean expression)有下面三�U�：

boolean1 && boolean2
boolean1 || boolean2
! boolean
6.3 条�g��式(Conditional Expressions)

一个条件式��式是一�U�特别的��式�Q�它含有3个运��元�?br>条�g式算式与C语言的相同：

selector ? if-true-exp : if-false-exp

它有3个子��式。第一个子��式selector 首先会被计算。如果是�?
则if-true-exp会被计算且它的值变成整个算式的倹{��否则if-false-
exp 会被计算且它的值变成整个算式的倹{�?/p>
例如下面的例子会产生x的绝对��|��

x>0 ? x : -x
�W�七�?Actions里面的控制叙�q?/p>
�?gawk �E�式里面�Q�控制叙�q�诸�?if、while �{�控制程式执行的��?br>�E�。在 gawk 里的控制叙述�?C 的类伹{�?/p>
很多的控制叙�q�C��包括其它的叙�q�ͼ�被包括的叙述�U�Cؓ body。假
�?body 里面包括一个以上的叙述�Q�必��M��大括�?{ } ��这些叙�q�括�?br>来，而各个叙�q�C��间需以换�?newline)或分号隔开�?br>7.1 if 叙述

if (condition) then-body [else else-body]

如果 condition 为真(true)�Q�则执行 then-body�Q�否则执�?else-body�?/p>
举一个例子如下：

if (x % 2 == 0)
print “x is even”
else
print “x is odd”
7.2 while 叙述

while (condition)
body

while 叙述做的�W�一件事��是��试 condition。假�?condition 为真�?br>执行 body 的叙�q�。body 的叙�q�执行完後，会再��试 condition�Q�假�?br>condition 为真�Q�则 body 会再度被执行。这个过�E�会一直被重复直到
condition 不再是真。如�?condition �W�一�ơ测试就是伪(false)�Q�则
body 从没有被执行�?/p>
下面的例子会印出每个输入记录(record)的前三个栏位�?/p>
gawk ‘{ i=1
while (i <= 3) {
print $i
i++
}
}'
7.3 do-while 叙述

do
body
while (condition)

�q�个 do loop 执行 body 一�ơ，然後只要 condition 是真则会重复执行 body�?br>即��开始时 condition 是伪�Q�body 也会被执行一�ơ�?/p>
下面的例子会印出每个输入记录十次�?/p>
gawk '{ i= 1
do {
print $0
i++
} while (i <= 10)
}'
7.4 for 叙述

for (initialization; condition; increment)
body

此叙�q�开始时会执行initialization�Q�然後只�?condition是真�Q�它
会重复执行body与做increment �?/p>
下面的例子会印出每个输入记录的前三个栏位�?/p>
gawk '{ for (i=1; i<=3; i++)
print $i
}'
7.5 break 叙述

break 叙述会蟩出包含它�?for、while、do-while 回圈的最内层�?/p>
下面的例子会扑և��M��整数的最��除敎ͼ�它也会判断是否�ؓ质数�?/p>
gawk '# find smallest divisor of num
{ num=$1
for (div=2; div*div <=num; div++)
if (num % div == 0)
break
if (num % div == 0)
printf "Smallest divisor of %d is %d\n", num, div
else
printf "%d is prime\n", num }'
7.6 continue 叙述

continue 叙述使用�?for、while、do-while 回圈内部�Q�它会蟩
�q�回�?body 的剩馀部分�Q��得它立刻�q�行下一�ơ回圈的执行�?/p>
下面的例子会印出 0 �?20 的全部数字，但是 5 �q�不会被印出�?/p>
gawk 'BEGIN {
for (x=0; x<=20; x++) {
if (x==5)
continue
printf ("%d",x)
}
print ""
}'
7.7 next 叙述、next file 叙述、exit 叙述

next 叙述�� gawk 立刻停止处理目前的记�?record)而��l�下一
个记录�?/p>
next file 叙述�c�M�� next。然而，它强�q?gawk 立刻停止处理目前
的资料档�?/p>
exit 叙述会��?gawk �E�式停止执行而蟩出。然而，如果 END 出现
�Q�它会去执行 END �?actions�?br>�W�八�?内徏函式(Built-in Functions)

内徏函式�?gawk 内徏的函式，可在 gawk �E�式的�Q何地方呼叫内�?br>函式�?br>8.1 数值方面的内徏函式

int(x) 求出 x 的整数部份，朝向 0 的方向做舍去。例如：int(3.9)
�?3�Q�int(-3.9) �?-3�?br>sqrt(x) 求出 x 正的�q�x��根倹{��例 sqrt(4)=2
exp(x) 求出 x 的次斏V��例 exp(2) ��x��?e*e �?br>log(x) 求出 x 的自然对数�?br>sin(x) 求出 x �?sine ��|��x 是弪度量�?br>cos(x) 求出 x �?cosine ��|��x 是弪度量�?br>atan2(y,x) �?y/x �?arctangent ��|��所求出的值其单位是弪度量�?br>rand() 得出一个�ؕ数倹{��此乱数值��^均分布在 0 �?1 之间。这�?br>��g��会是 0�Q�也不会�?1�?br>每次执行 gawk�Q�rand 开始��生数字从相同�Ҏ(gu��)�� seed�?br>srand(x) 讑֮�产生乱数的开始点�?seed �?x。如果在�W�二�ơ你�?br>定相同的 seed ��|��你将再度得到相同序列的�ؕ数倹{�?br>如果省略引数 x�Q�例�?srand()�Q�则现在的日期、时间会
被当�?seed。这个方法可使得乱数值是真正不可预测的�?br>srand 的传回�?return value)是前�ơ所讑֮��?seed 倹{�?br>8.2 字串斚w��的内建函�?/p>
index(in, find)
它会在字�?in 里面�Q�寻扑֭��?find �W�一�ơ出现的地方�Q�传回值是
字串 find 出现在字�?in 里面的位�|�。如果在字串 in 里面找不到字
�?find�Q�则传回��gؓ 0�?br>例如�Q?br>print index("peanut","an")
会印�?3�?/p>
length(string)
求出 string 有几个字元�?br>例如�Q?br>length("abcde")
�?5�?/p>
match(string,regexp)
match 函式会在字串 string 里面�Q�寻扄��?regexp 的最�ѝ��最�?br>左边的子字串。传回值是 regexp �?string 的开始位�|�，�?index
倹{�?br>match 函式会设定内在变�?RSTART �{�於 index�Q�它也会讑֮�内在�?br>�?RLENGTH �{�於�W�合的字元个数。如果不�W�合�Q�则会设�?RSTART �?br>0、RLENGTH �?-1�?/p>
sprintf(format,expression1,...)
�?printf �c�M��Q�但�?sprintf �q�不印出�Q�而是传回字串�?br>例如�Q?br>sprintf("pi = %.2f (approx.)',22/7)
传回的字串�ؓ"pi = 3.14 (approx.)"

sub(regexp, replacement,target)
在字�?target 里面�Q�寻扄��?regexp 的最�ѝ��最靠左边的地方�Q?br>以字�?replacement 代替最左边�?regexp�?br>例如�Q?br>str = "water, water, everywhere"
sub(/at/, "ith",str)
�l�果字串str会变�?br>"wither, water, everywhere"

gsub(regexp, replacement, target)
gsub 与前面的 sub �c�M��。在字串 target 里面�Q�寻扄��?regexp �?br>所有地方，以字�?replacement 代替所有的 regexp�?br>例如�Q?br>str="water, water, everywhere"
gsub(/at/, "ith",str)
�l�果字串str会变�?br>'wither, wither, everywhere"

substr(string, start, length)
传回字串 string 的子字串�Q�这个子字串的长度�ؓ length 个字元，
从第 start 个位�|�开始�?br>例如�Q?br>substr("washington",5,3)
传回��gؓ"ing"
如果 length 没有出现�Q�则传回的子字串是从�W?start 个位�|�开�?br>至结束�?br>例如�Q?br>substr("washington",5)
传回��gؓ"ington"

tolower(string)
��字串string的大写字母改为小写字母�?br>例如�Q?br>tolower("MiXeD cAsE 123")
传回��gؓ"mixed case 123"

toupper(string)
��字串string的小写字母改为大写字母�?br>例如�Q?br>toupper("MiXeD cAsE 123")
传回��gؓ"MIXED CASE 123"
8.3 输入输出的内建函�?/p>
close(filename)
��输入或输出的档�?filename 关闭�?/p>
system(command)
此函式允�怋�用者执行作业系�l�的指��o�Q�执行完毕後��回�?gawk
�E�式�?br>例如�Q?br>BEGIN {system("ls")}
�W�九(ji��)�?使用者定义的函式(User-defined Functions)

复杂�?gawk �E�式常常可以使用自己定义的函式来��化。呼叫��?br>者定义的函式与呼叫内建函式的�Ҏ(gu��)��一栗��?br>9.1 函式定义的格�?/p>
函式的定义可以放�?gawk �E�式的�Q何地斏V�?/p>
一个��用者定义的函式其格式如下：

function name (parameter-list) {
body-of-function
}

name 是所定义的函式之名称。一个正��的函式名称可包括一序列的字
母、数字、下标线 (underscores)�Q�但是不可用数字做开头�?/p>
parameter-list 是列出函式的全部引数(argument)�Q�各个引��C��
间以逗点隔开�?/p>
body-of-function 包含 gawk 的叙�q?(statement)。它是函式定�?br>里最重要的部份，它决定函式实际要做何�U�事�?br>9.2 函式定义的例�?/p>
下面�q�个例子�Q�会��每个记录的�W�一个栏位之值的�q�x��与第二个
栏位之值的�q�x��加�v来�?/p>
{print "sum =",SquareSum($1,$2)}
function SquareSum(x,y) {
sum=x*x+y*y
return sum
}
�W�十�?□例

�q�里��列�?gawk �E�式的一些例子�?/p>
gawk '{if (NF > max) max = NF}
END {print max}’
此程式会印出所有输入行之中�Q�栏位的最大个数�?/p>
gawk ‘length($0) > 80′
此程式会印出一行超�q?80 个字元的每一行。此处只�?pattern �?br>列出�Q�action 是采用内定的 print�?/p>
gawk ‘NF > 0′
�Ҏ(gu��)��拥有臛_��一个栏位的所有行�Q�此�E�式皆会印出。这是一个简
单的�Ҏ(gu��)��Q�将一个档案里的所有空白行删除�?/p>
gawk ‘{if (NF > 0) print}’
�Ҏ(gu��)��拥有臛_��一个栏位的所有行�Q�此�E�式皆会印出。这是一个简
单的�Ҏ(gu��)��Q�将一个档案里的所有空白行删除�?/p>
gawk ‘BEGIN {for (i = 1; i <= 7; i++)
print int(101 * rand())}'
此程式会印出□围�?0 �?100 之间�?7 个�ؕ数倹{�?/p>
ls -l files | gawk '{x += $4}; END {print "total bytes: " x}'
此程式会印出所有指定的档案之bytes数目的��d��?/p>
expand file | gawk '{if (x < length()) x = length()}
END {print "maximum line length is " x}'
此程式会��指定档案里最长一行的长度印出。expand 会将 tab �?br>�?space�Q�所以是用实际的双��界来做长度的比较�?/p>
gawk 'BEGIN {FS = ":"}
{print $1 | "sort"}' /etc/passwd
此程式会��所有��用者的login名称�Q�依照字母的��序印出�?/p>
gawk '{nlines++}
END {print nlines}'
此程式会��一个档案的总行数印出�?/p>
gawk 'END {print NR}'
此程式也会将一个档案的总行数印出，但是计算行数的工作由gawk
来做�?/p>
gawk '{print NR,$0}'
此程式印出档案的内容�Ӟ��会在每行的最前面印出行号�Q�它的功
能与 'cat -n' �c�M��?br>�W�十一�?�l�论

gawk �Ҏ(gu��)��资料的处理具有很强的功能。它能够以很短的�E�式完成
惌��做的事，甚至一或二行的�E�式��p��完成指定的工作。同��L��一�?br>工作�Q�以 gawk �E�式来写会比用其它程式语�a�来写短很多�?/p>
gawk �?GNU 所做的 awk�Q�它是公众��Y�?Public Domain) 可免费��
用�?br>(http://www.fanqiang.com)

原文链接�Q?a >http://www.phpx.com/happy/top58375.html

megax 2008-03-11 14:06 发表评论

[转]DB2 9 ��理之服务器��理

megax — Tue, 11 Mar 2008 06:04:00 GMT

DB2 实例是一�U�逻辑上下文，DB2 命��o及函数在其中执行。�?zh��n)�可将实例视�ؓ��理��?gu��)��据库文�g的访问的服务或守护进�E�。在一台服务器上可定义多个实例。各实例独立于其他实例，也就是说所有实例均可分别管理、操�U�及调优�?/p>

　　一、DB2 实例

　　1、创建及删除实例

　　DB2 实例是一�U�逻辑上下文，DB2 命��o及函数在其中执行。�?zh��n)�可将实例视�ؓ��理��?gu��)��据库文�g的访问的服务或守护进�E�。在一台服务器上可定义多个实例。各实例独立于其他实例，也就是说所有实例均可分别管理、操�U�及调优�?/p>
　　要在 Windows 中创建实例，只需执行以下命��o�Q?/p>

db2icrt instance_name

　　�?Linux �?UNIX 中，�(zh��n)�必��d��外提供一个用�?ID�Q�用以创�?fenced 用户定义的函数和存储�q�程�q�程�Q��Ş式如下：

db2icrt -u fenced_user_ID instance_name

　　默认情况下，用户定义的函数和存储�q�程是在 fenced 模式下创建的�Q�因而这些进�E�运行在�?DB2 引擎不同的地址�I�间中，也称为系�l�控制器�q�程 db2sysc。这为数据库��理器提供了保护�Q��之免于被用户定义的例�E�意外地或恶意地破坏�?/p>
　　要删除一个实例，首先断开所有数据库�q�接�Q�然后执行以下命令停止实例：

db2idrop -f instance_name

　　2、列举、迁�U�d��更新 DB2 实例

　　要列举服务器上存在的 DB2 实例�Q�可使用以下命��o�Q?/p>

db2ilist

　　若�?zh��n)�军_��转而��用比服务器上安装�?DB2 软�g更新的版本，或者需要将 32 位实例迁�U�Mؓ 64 位实例，��需要进行实例迁�U�R��在Windows 上，实例�q�移是在必要的迁�U�过�E�中隐式完成的。在 Linux �?UNIX 上，可��用以下命令显式地�q�移已有实例�Q?/p>

db2imigr instance_name

　　在�ؓ DB2 安装修补�E�序包或补丁�Ӟ��一旦在服务器上安装好了修补�E�序包，�(zh��n)�就需要更新已有实例，以链接到新的修补�E�序文�g。��用以下命令更新实例：

db2iupdt instance_name

3、设�|?DB2 环境　　恰当地设�|?DB2 环境非常重要�Q�这是因为它控制着 DB2 操作和活动的方式。DB2 环境�׃��下几部分构成�Q?/p>
　　�?DB2 配置文�g注册�?/p>
　　�?操作�pȝ��环境变量

　　�?DB2 数据库管理器配置参数

　　�?DB2 数据库配�|�参�?/p>
　　4、设�|�配�|�文件注册库

　　DB2 配置文�g注册库是特定�?DB2 的变量，它会影响 DB2 �pȝ��的管理、配�|�与性能。�ؓ�?DB2 配置文�g注册库的更改生效�Q��?zh��n)�通常需要停止�ƈ重启实例�?/p>
　　要列举所支持的全�?DB2 配置文�g注册库：

db2set -lr

　　要设�|?DB2 配置文�g注册库：

db2set registry_variable = value

　　��h��意，在变量名、等号和变量��g��间没有空根{��下面给��Z��个将 DB2COMM 注册库变量设�|��ؓ单一值的�C�Z��Q?/p>

db2set DB2COMM=TCPIP

　　��?DB2COMM 注册库变量设�|��ؓ多个值的�C�Z��如下�Q?/p>

db2set DB2COMM=TCPIP,NPIPE,LOCAL

　　要将 DB2 配置文�g注册库重�|��ؓ默认��|��只需使用与上面相同的命��o卛_��Q�但不指定�Q何��|��

db2set registry_variable =

　　要显�C�服务器上当前设�|�的所�?DB2 配置文�g注册库，��h��行以下命令：

db2set -all

5、设�|�系�l�环境变量　　要了解�?zh��n)�当前工作在哪�?DB2 实例中，可运行以�?DB2 命��o�Q?/p>

db2 get instance

　　此命令的输出�l�果形式如下�Q?/p>

The current database manager instance is: DB2

　　�l�大多数 DB2 环境讄��都是�?DB2 配置文�g注册库控制的。而那些未存储在配�|�文件注册库中的讄��U�Cؓ操作�pȝ��环境变量。设�|�系�l�变量的命��o��根据�?zh��n)�所使用的��^台及 UNIX shell 而有所不同�?/p>
　　�?�?Windows 中： set DB2INSTANCE=DB2

　　�?�?Linux �?UNIX �?Korn shell 中： export DB2INSTANCE=DB2

　　DB2INSTANCE 是一个需要掌握的重要�pȝ��变量。它指定当前应用�E�序的会话或�H�口的默�?DB2 实例。一旦设�|�好该变量，后箋的所�?DB2 命��o都将在该实例的作用域内执行�?/p>
　　6、设�|�配�|�参�?/p>
　　�?DB2 中，存在两个配置 “�U�别”。在实例(或数据库��理�?�U�别�Q��?zh��n)�可�ؓ该实例配�|�整�?DB2 环境�Q�这��媄响实例中的所有数据库和��用该实例中数据库的所有应用程序。在数据�?�U�别�Q��?zh��n)�可配�|�参敎ͼ�而这些参数将影响到访问特定数据库的所有应用程序的行�ؓ�?/p>
　　获取 DBMS 或�?DB 的配�|�参敎ͼ�

db2 get database manager configuration
db2 get database configuration for database_name

　　或�?后同)

db2 get database manager cfg
db2 get database cfg for database_name

　　更改 DBMS 或�?DB 的配�|�参�?/p>

db2 update database manager configuration using parameter new_value
db2 update database configuration for database_name using parameter new_value

7、联��|�配�|�参数　　�l�大多数配置参数均可在实例或数据库保持运行的情况下联��|�。只要可能，对这些联机配�|�参数的更改默认为立即生效。例如，若更改了 sortheap 的��|��所有新�?SQL ��h��用新倹{��ؓ昑ּ�指定�q�种立即生效的行为，可将 immediate 关键字附加到 update 命��o中：

db2 update database manager configuration using parameter new_value immediate
db2 update database configuration for database_name using parameter new_value immediate

　　若�?zh��n)�选择��此更改延迟臛_��例重启或数据库激�z�L��Q�则应指�?deferred 关键字：

db2 update database manager configuration using parameter new_value deferred
db2 update database configuration for database_name using parameter new_value deferred

　　有时�Q��?zh��n)�可能希望扑և�已确定�ƈ延迟了哪些更攏V��ؓ昄��数据库管理器配置参数的当前值和挂�v��|��首先�q�入实例�Q�然后在 get database manager configuration 命��o中指�?show detail 选项�Q�方法如�?��h��意，instance_name 是系�l�环境变�?DB2INSTANCE 讄��的�?�Q?/p>

db2 attach to instance_name
db2 get database manager configuration show detail

　　同样圎ͼ�要列举数据库配置参数的当前值和挂�v��|��首先�q�接到数据库�Q�然后��?show detail 选项�Q?/p>

db2 connect to database_name
db2 get database configuration for database_name show detail

　　8、强制停止实例和数据�?/p>
　　如果�(zh��n)�需要��数据库或数据库管理器配置更改立即生效�Q�而�?zh��n)�所更改的参数�ƈ非动态，那么��需要停止�ƈ重启数据库或整个实例。若存在�q�接�q��用此实例中一个或多个数据库的应用�E�序�Q��?zh��n)��无法停止�ƈ重启数据库或实例。此�Ӟ��(zh��n)�可使用如下 DB2 命��o�Q�强行��用户断开与数据库的连接：

db2 force application all

　　�(zh��n)�也可以在停止实例的同时断开所有用��L��q�接�Q�命令如下：

db2stop force

　　若�?zh��n)�只希望强制停止一个特定的应用�E�序�Q�则需要了解该应用�E�序的句柄�?使用以下命��o查找句柄�Q?/p>

db2 list applications

　　强制停止该应用程序的�q�接�Q�可使用如下 DB2 命��o�Q?x ��应用�E�序句柄)

db2 force application (x)

　二、DB2 客户�?服务器连通�?/strong>　　1、DB2 客户�?服务器环�?/p>
　　�׃�� DB2 用户间整体通信协议使用情况发生了变化，因此为实�?DB2 客户�?服务器连通性，

　　DB2 目前支持以下协议�Q?/p>
　　�?TCP/IP

　　�?NPIPE

　　对于��C��数据�?�?DB2 for z/OS �?�?DB2 for iSeries)的连接，必须具备使用 Distributed Relational Database Architecture(DRDA)�?DB2 Connect�?/p>
　　2、�ؓ�q�程应用�E�序�q�接准备�(zh��n)�的 DB2 数据�?/p>
　　�?DB2 客户�?应用�E�序)能够�q�接到数据库之前�Q��?zh��n)�必须��保服务器端通信得到了恰当的讄��Q�可接收�q�接��h��。要�?TCP/IP �q�接准备服务器，�(zh��n)�需要设�|�一�?TCP/IP 监听器，�Ҏ(gu��)��如下�?/p>
　　(1)�?使用以下命��o讄�� DB2 配置文�g注册�?DB2COMM�Q��实例能够监听 TCP/IP 的连接：

db2set DB2COMM=TCPIP

　　(2)、��用正��的端口��h��新数据库��理器配�|�参�?svcename�Q�如下所�C�：

db2 update database manager configuration using svcename 50000

　　(3)、数据库��理器配�|�参�?svcename �q��动态，因此�(zh��n)�必��d��止�ƈ重启实例�Q�以�?TCP/IP 监听器启动，如下所�C�：

db2stop
db2start

　　3、��?DB2 Configuration Assistant

　　DB2 Configuration Assistant 提供了用户友好的向导和图形化界面�Q�可配置�(zh��n)�或�(zh��n)�的应用�E�序��用的环境。通过 Configuration Assistant�Q��?zh��n)�可以�Q?/p>
　　�?��d��一个新的数据库�q�接

　　�?更新数据库连通性信�?/p>
　　�?查看�q�更新数据库��理器配�|�参�?/p>
　　�?查看�q�更�?DB2 配置文�g注册�?/p>
　　�?��应用程序绑定到数据�?/p>
　　�?更新 Call Level Interface(CLI)讄��

　4、配�|�数据库�q�通性的三种�Ҏ(gu��)��

　　�?DB2 Configuration Assistant 中，有三个选项可用于设�|�数据库�q�接。�?zh��n)�可以�Q?/p>
　　�?�?DB2 数据库搜索网�l?/p>
　　�?使用 DB2 讉K��配置文�g

　　�?手动配置�q�接

　　5、通过搜烦�|�络自动配置数据库连通�?/p>
　　DB2 Discovery 搜烦�q�定位�?zh��n)�的网�l�上�?DB2 服务器，�(zh��n)�可以选择使用搜烦或已�?发现�Ҏ(gu��)��?/p>
　　搜烦�Ҏ(gu��)��在�|�络中搜索�Q�?DB2 服务器。这�U�方法需要花上一些时间才能返回结果�?/p>
　　如果�(zh��n)�知道一些关于希望定位的 DB2 服务器的信息�Q�则可��用已知方法，�q�提供数据库或服务器名称之类的信息来�U�束搜烦�?/p>
　　DB2 允许某些 DB2 服务器、实例或数据库可以被发现或者不被发现�?/p>
　　仅在 DB2 服务器上�q�行 Administration Server(DAS)服务、且 discover 配置参数被设�|��ؓ search �Ӟ��?DB2 服务器才可被搜烦刎ͼ�如下所�C�：

db2admin start
db2 update admin configuration using discover search

　　�(zh��n)�还可控制哪些实例是可被发现的，只需讄�� discover_inst 数据库管理器配置参数卛_��Q�如下所�C�：

db2 update database manager configuration using discover_inst enable

　　各数据库都拥有一个相似的配置参数 —�?discover_db�Q�它可启用或��用数据库发玎ͼ�如下所�C�：

db2 update database configuration for database_name using discover_db enable

　　�q�里要重�Ҏ(gu��)��出，�?DAS、实例或数据库��别禁用发��C��会限�?DB2 客户机通过其他�Ҏ(gu��)��讄��数据库连通�?下文��详�l�讨�?。DB2 客户��Z��然可以连接到�q�程数据�?—�?即便其数据库配置 discover_db 被禁用也是如此�?/p>
　6、��?DB2 讉K��配置文�g自动配置数据库连通�?/p>
　　如果�(zh��n)�要�?1,000 台或更多的工作站讄�� DB2 客户�?服务器连通性，那么�(zh��n)�会怎么�?�(zh��n)�当然可以前往每一台工作站�Q��用Configuration Assistant 中的发现�Ҏ(gu��)��Q�但可能要花上很长一�D�|��间才能完成这个�Q务。在此类情况下，�(zh��n)�应考虑使用 DB2 讉K��配置文�g�?/p>
　　讉K��配置文�g中包含客��h��配置�?DB2 服务器的�q�通性时所必需的信息。访问配�|�文件有两种�c�d��Q?/p>
　　�?服务器访问配�|�文�?是在 DB2 服务器上生成的。它包含服务器上定义的全部或选定的部分实例和数据库的相关信息�?/p>
　　�?客户机配�|�文�?是在 DB2 客户��Z��生成的。它包含客户��Z��已编目的实例(也称��?和数据库的相关信息�?/p>
　　让我们逐步地看一�?DB2 讉K��配置文�g�Ҏ(gu��)��?/p>
　　(1)、��?Configuration Assistant ��信息导出到讉K��配置文�g(该文件就是一�?ASCII 文�g)�?/p>
　　(2)、将导出的文件发送给客户机�?/p>
　　(3)、在客户��Z��使用 Configuration Assistant ��文件导�?DB2 客户机�?/p>
　　�W�三个步骤也可以使用命��o实现�Q?/p>

db2cfimp access_profile_name

　　7、手动配�|�数据库�q�通�?/p>
　　如果�(zh��n)�了解配�|�连通性所必需的所有信息，那么可以使用 Configuration Assistant 中的 Add Database 向导�?/p>
　　(1)、必��首先编目节�?�?DB2 服务�?与实例的�l�合�?/p>

db2 catalog tcpip node mynode remote db2server.mycompany.com server db2icdb
db2 catalog netbios node jeremy remote N01FCBE3 adapter 0

　　(2)、编目数据库

db2 catalog database sample as mysamp at node mynode
db2 catalog database baydb as newbaydb at node mynode

　8、列举节点和数据库目录　　要在 node 目录中列举服务器与实例的�l�合�Q�可使用如下命��o�Q?/p>

db2 list node directory

　　要列�?database 目录�Q�可使用如下命��o�Q?/p>

db2 list database directory

　　9、附加到实例�q�连接到数据�?/p>
　　通过�~�目节点和数据库讄��完客��h��/服务器连通性后�Q��?zh��n)�可附加到实例以进行实例�񔽎�理��d��Q�也可连接到数据库以��d��该数据库中的数据或向数据库写入数据�?/p>
　　要附加到 DB2 实例�Q�可使用 DB2 命��o attach�Q�如下所�C�：

attach to nodename user username using password

　　附加到实例后�Q��?zh��n)�可在该实例上执行��理��d��Q�例如：

　　�?创徏和删除数据库

　　�?��索、更新和重置数据库管理器及数据库配置参数

　　�?��理数据库监控程�?/p>
　　�?备䆾、还原和前滚数据�?/p>
　　�?强制用户和应用程序与实例中定义的数据库断开�q�接

　　要连接到数据库，以选择、插入、更新或删除数据�Q��?zh��n)�必须首先通过以下方式�q�接到数据库�Q?/p>

connect to database_name user username using password
[new new_password confirm new_password ]

　　�q�接到数据库之后�Q�就可以�q�行数据库的相应操作了�?/p>

megax 2008-03-11 14:04 发表评论

午夜精品久久久久久,亚洲高清影视,国产一区二区高清不卡

[转]字符转换

[转]vi常用操作

[转]Linux常见问题解答

[转]AWK说明

[转]grep 用法

[转]gawk 手册

[转]DB2 9 ���理之服务器���理

[转]DB2 9 ��理之服务器��理