2009年7月 归档

本人原本是国营企业的职工，后来买断工龄，工厂解散了，仅仅留下老厂长和几个老职工留下解决我们的社保等问题，以及厂区职工生活区的物业管理问题。当年同厂的职工后来在新厂长的带领下又自筹资金（股金）办了个公司，搞的风风火火的，解决了大批下岗职工的就业问题。这样的国营企业改制方案很得人心。

而我父母亲单位的国营企业改制就搞的乱七八糟的，名义说是MBO，其实不然。先解释下名词：

MBO是管理层收购（Management-Buy-out）的简称，是指公司的管理者或经理层利用杠杆收购的方式，利用借贷融资买断或控制公司的股份，旨于改变公司的所有者结构、控制权结构和资产结构，使企业原经营者变成企业所有者的一种收购行为。

我国出现管理层收购的背景源于我国国有经济战略性重组以及国有资产管理体制改革的开展，各级政府希望能籍管理层收购这一手段来让渡部分国有资产、回收资金以进一步对产业结构进行调整。而企业的管理层也想以管理层收购的方式来明晰企业产权，达到企业的所有权和经营权合一的目的。

MBO是我国国有企业从上世纪90年代以来引进探索的一种产权制度改革方式。然而几乎从实行之日起，一些经济学家就从未停止过对这种方式的质疑。一些专家认为，在国有资产出资人监管角色尚未到位的情况下，大规模实行管理层持股容易给企业带来五大风险：
一是定价环节中的风险，例如行政干预，协议转让等；
二是信息不对称，暗箱操作的风险，例如，先做亏公司再低价购进；
三是收购者融资渠道不明的风险；
四是运作风险；
五是收购主体合法性不能保证的风险。所以应当立即停止。

看完了上面的名词解释您应该理解什么是中国国企的MBO了吧。

我父母亲单位的MBO就是这样的，要改制了，厂长跟主管部门说我要MBO，好了就开始定价拆股，厂长定180万占大股，下面的职工开始投股，投股了才有班上，没有投股的就下岗。投大股的可以进管理岗位，可以进董事会。厂长的180万不知道有没有到位，能到位就有问题了，180万啊，一个常年不景气的工厂厂长有这么多钱？有才怪了，说是借的，这年头钱好借吗？反正也就这么着过关了。MBO之后，工厂该亏损还是亏损，不可能因为经营的主体发生了变化企业就盈利了吧。没有办法，就开始出租厂房过日子。

如今不行了，欠电费水费一屁股的债，没钱了。这帮当年跟着入股的，多则20万，少则3万，都没了。但是当年MBO的主角呢？这里买房子了，那里也买房子，车子也有了！他一点损失也没有。

塞翁失马，焉知非福。我父亲当年也投股了，但是没多久我惹官非，为了救我，我父亲无奈撤股，同时也就下岗了。当时我感觉很对不起我父亲，害他失去自己工作数十年的工作岗位。一时间，我父亲在我们家也就是工厂的生活区都不想出门，怕碰见老工友。原本在管理岗位上天天喝酒，后来也没人请了。后来在我母亲（跟我父亲已个单位，在MBO前就退休了）的帮助下做起了小生意，现在月入3000～5000，以前那些工友反而羡慕我父亲。离开了国营单位的圈子，喝酒少了，身体也好了。反观那些入股的，现在苦了啊，血本无归。

今天，父亲单位的书记也是我们家的好朋友，在去省里求助主管单位解决工厂的问题的时候在高速公路淮安段出车祸死亡，总共2死1伤。悼念他，愿死者安息，伤者平安！

中国大部分的国营企业的MBO结局大致如此吧，MBO害死人。

大部分的浏览器一个网站只支持保存20个Cookie，超过20个Cookie，旧的Cookie会被最新的Cookie代替。那么如果要有超过20个Cookie要保存只能将Cookie存为数组然后保存到Cookie。JavaScript中数组是无法直接保存为Cookie的（PHP可以），那要将数组转存为字符串，再保存在Cookie中，简单的一维数组我们直接用toString()或者join就可以了：

JavaScript中toString函数方法是返回对象的字符串表示。
使用方法：objectname.toString([radix])
其中objectname是必选项。要得到字符串表示的对象。
radix是可选项。指定将数字值转换为字符串时的进制。

join是其中一个方法。
格式：objArray.join(seperator)
用途：以seperator指定的字符作为分隔符，将数组转换为字符串，当seperator为逗号时，其作用和toString()相同。

如果多维数组，我们就要用JSON了。

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。这些特性使JSON成为理想的数据交换语言。

这里我们使用PHP2JS的函数库来实现，需要 json_decode 和 json_encode这两个函数，懂PHP的朋友可以理解这两个函数的意思。json_decode 是JSON到数组，json_encode 是数组到JSON。

需要注意的是JavaScript 保存 Cookie 会将一些字符过滤，如："{" 被过滤为 "{_" 等。所以在获取 Cookie 时要过滤这些字符，不然 json_decode 会出错。

下面简单举例如下：

<script type="text/javascript">
function setCookie(name, value){
	document.cookie = name + "="+ value;
}

function getCookie(name){
	var arr = document.cookie.match(new RegExp("(^| )"+name+"=([^;]*)(;|$)"));
	if(arr != null) return unescape(arr[2]); return '';
}

function savecookie(){
	var dc = {};
	
	dc['a'] = {};
	dc['a']['x'] = 'ax';
	dc['a']['y'] = 'ay';
	dc['a']['z'] = 'az';
	
	dc['b'] = {};
	dc['b']['x'] = 'bx';
	dc['b']['y'] = 'by';
	dc['b']['z'] = 'bz';
	
	var cdc = json_encode(dc);
	setCookie('testcookie', cdc);
}

function clearcookie(){
	setCookie('testcookie', '');
}

function readcookie(){
	var cdc = getCookie('testcookie');
	cdc = cdc.replace(/,_/g, ',');
	cdc = cdc.replace(/{_/g, '{');
	cdc = cdc.replace(/_}/g, '}');

	var dc = json_decode(cdc);
	for(i in dc){
		for(j in dc[i]){
			document.write(i +':'+ j +':'+ dc[i][j] +'<br>');
		}
	}
}

function json_decode(str_json) {
    // Decodes the JSON representation into a PHP value
    //
    // version: 906.1806
    // discuss at: http://phpjs.org/functions/json_decode
    // +      original by: Public Domain (http://www.json.org/json2.js)
    // + reimplemented by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // + improved by: T.J. Leahy
    // *     example 1: json_decode('[\n    "e",\n    {\n    "pluribus": "unum"\n}\n]');
    // *     returns 1: ['e', {pluribus: 'unum'}]
    /*
        http://www.JSON.org/json2.js
        2008-11-19
        Public Domain.
        NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
        See http://www.JSON.org/js.html
    */

    var json = this.window.JSON;
    if (typeof json === 'object' && typeof json.parse === 'function') {
        return json.parse(str_json);
    }

    var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
    var j;
    var text = str_json;

    // Parsing happens in four stages. In the first stage, we replace certain
    // Unicode characters with escape sequences. JavaScript handles many characters
    // incorrectly, either silently deleting them, or treating them as line endings.
    cx.lastIndex = 0;
    if (cx.test(text)) {
        text = text.replace(cx, function (a) {
            return '\\u' +
            ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
        });
    }

    // In the second stage, we run the text against regular expressions that look
    // for non-JSON patterns. We are especially concerned with '()' and 'new'
    // because they can cause invocation, and '=' because it can cause mutation.
    // But just to be safe, we want to reject all unexpected forms.

    // We split the second stage into 4 regexp operations in order to work around
    // crippling inefficiencies in IE's and Safari's regexp engines. First we
    // replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
    // replace all simple value tokens with ']' characters. Third, we delete all
    // open brackets that follow a colon or comma or that begin the text. Finally,
    // we look to see that the remaining characters are only whitespace or ']' or
    // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
    if (/^[\],:{}\s]*$/.
        test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@').
            replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').
            replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {

        // In the third stage we use the eval function to compile the text into a
        // JavaScript structure. The '{' operator is subject to a syntactic ambiguity
        // in JavaScript: it can begin a block or an object literal. We wrap the text
        // in parens to eliminate the ambiguity.

        j = eval('(' + text + ')');

        return j;
    }

    // If the text is not JSON parseable, then a SyntaxError is thrown.
    throw new SyntaxError('json_decode');
}

function json_encode(mixed_val) {
    // Returns the JSON representation of a value
    //
    // version: 906.1806
    // discuss at: http://phpjs.org/functions/json_encode
    // +      original by: Public Domain (http://www.json.org/json2.js)
    // + reimplemented by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // + improved by: T.J. Leahy
    // *     example 1: json_encode(['e', {pluribus: 'unum'}]);
    // *     returns 1: '[\n    "e",\n    {\n    "pluribus": "unum"\n}\n]'
    /*
        http://www.JSON.org/json2.js
        2008-11-19
        Public Domain.
        NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
        See http://www.JSON.org/js.html
    */
    var json = this.window.JSON;
    if (typeof json === 'object' && typeof json.stringify === 'function') {
        return json.stringify(mixed_val);
    }

    var value = mixed_val;

    var quote = function (string) {
        var escapable = /[\\\"\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
        var meta = {    // table of character substitutions
            '\b': '\\b',
            '\t': '\\t',
            '\n': '\\n',
            '\f': '\\f',
            '\r': '\\r',
            '"' : '\\"',
            '\\': '\\\\'
        };

        escapable.lastIndex = 0;
        return escapable.test(string) ?
        '"' + string.replace(escapable, function (a) {
            var c = meta[a];
            return typeof c === 'string' ? c :
            '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
        }) + '"' :
        '"' + string + '"';
    };

    var str = function(key, holder) {
        var gap = '';
        var indent = '    ';
        var i = 0;          // The loop counter.
        var k = '';          // The member key.
        var v = '';          // The member value.
        var length = 0;
        var mind = gap;
        var partial = [];
        var value = holder[key];

        // If the value has a toJSON method, call it to obtain a replacement value.
        if (value && typeof value === 'object' &&
            typeof value.toJSON === 'function') {
            value = value.toJSON(key);
        }

        // What happens next depends on the value's type.
        switch (typeof value) {
            case 'string':
                return quote(value);

            case 'number':
                // JSON numbers must be finite. Encode non-finite numbers as null.
                return isFinite(value) ? String(value) : 'null';

            case 'boolean':
            case 'null':
                // If the value is a boolean or null, convert it to a string. Note:
                // typeof null does not produce 'null'. The case is included here in
                // the remote chance that this gets fixed someday.

                return String(value);

            case 'object':
                // If the type is 'object', we might be dealing with an object or an array or
                // null.
                // Due to a specification blunder in ECMAScript, typeof null is 'object',
                // so watch out for that case.
                if (!value) {
                    return 'null';
                }

                // Make an array to hold the partial results of stringifying this object value.
                gap += indent;
                partial = [];

                // Is the value an array?
                if (Object.prototype.toString.apply(value) === '[object Array]') {
                    // The value is an array. Stringify every element. Use null as a placeholder
                    // for non-JSON values.

                    length = value.length;
                    for (i = 0; i < length; i += 1) {
                        partial[i] = str(i, value) || 'null';
                    }

                    // Join all of the elements together, separated with commas, and wrap them in
                    // brackets.
                    v = partial.length === 0 ? '[]' :
                    gap ? '[\n' + gap +
                    partial.join(',\n' + gap) + '\n' +
                    mind + ']' :
                    '[' + partial.join(',') + ']';
                    gap = mind;
                    return v;
                }

                // Iterate through all of the keys in the object.
                for (k in value) {
                    if (Object.hasOwnProperty.call(value, k)) {
                        v = str(k, value);
                        if (v) {
                            partial.push(quote(k) + (gap ? ': ' : ':') + v);
                        }
                    }
                }

                // Join all of the member texts together, separated with commas,
                // and wrap them in braces.
                v = partial.length === 0 ? '{}' :
                gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' +
                mind + '}' : '{' + partial.join(',') + '}';
                gap = mind;
                return v;
        }
    };

    // Make a fake root object containing our value under the key of ''.
    // Return the result of stringifying the value.
    return str('', {
        '': value
    });
}

savecookie();
readcookie();
</script>

还要注意的就是中文问题，可能会乱码，建议将多字节字符及中文等用 base64 编码解码：

<script type="text/javascript">
function base64_decode( data ) {
    // Decodes string using MIME base64 algorithm
    //
    // version: 905.3122
    // discuss at: http://phpjs.org/functions/base64_decode
    // +   original by: Tyler Akins (http://rumkin.com)
    // +   improved by: Thunder.m
    // +      input by: Aman Gupta
    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +   bugfixed by: Onno Marsman
    // +   bugfixed by: Pellentesque Malesuada
    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +      input by: Brett Zamir (http://brett-zamir.me)
    // +   bugfixed by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // -    depends on: utf8_decode
    // *     example 1: base64_decode('S2V2aW4gdmFuIFpvbm5ldmVsZA==');
    // *     returns 1: 'Kevin van Zonneveld'
    // mozilla has this native
    // - but breaks in 2.0.0.12!
    //if (typeof this.window['btoa'] == 'function') {
    //    return btoa(data);
    //}

    var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
    var o1, o2, o3, h1, h2, h3, h4, bits, i = 0, ac = 0, dec = "", tmp_arr = [];

    if (!data) {
        return data;
    }

    data += '';

    do {  // unpack four hexets into three octets using index points in b64
        h1 = b64.indexOf(data.charAt(i++));
        h2 = b64.indexOf(data.charAt(i++));
        h3 = b64.indexOf(data.charAt(i++));
        h4 = b64.indexOf(data.charAt(i++));

        bits = h1<<18 | h2<<12 | h3<<6 | h4;

        o1 = bits>>16 & 0xff;
        o2 = bits>>8 & 0xff;
        o3 = bits & 0xff;

        if (h3 == 64) {
            tmp_arr[ac++] = String.fromCharCode(o1);
        } else if (h4 == 64) {
            tmp_arr[ac++] = String.fromCharCode(o1, o2);
        } else {
            tmp_arr[ac++] = String.fromCharCode(o1, o2, o3);
        }
    } while (i < data.length);

    dec = tmp_arr.join('');
    dec = this.utf8_decode(dec);

    return dec;
}

function base64_encode( data ) {
    // Encodes string using MIME base64 algorithm
    //
    // version: 905.2617
    // discuss at: http://phpjs.org/functions/base64_encode
    // +   original by: Tyler Akins (http://rumkin.com)
    // +   improved by: Bayron Guevara
    // +   improved by: Thunder.m
    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +   bugfixed by: Pellentesque Malesuada
    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // -    depends on: utf8_encode
    // *     example 1: base64_encode('Kevin van Zonneveld');
    // *     returns 1: 'S2V2aW4gdmFuIFpvbm5ldmVsZA=='
    // mozilla has this native
    // - but breaks in 2.0.0.12!
    //if (typeof this.window['atob'] == 'function') {
    //    return atob(data);
    //}

    var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
    var o1, o2, o3, h1, h2, h3, h4, bits, i = 0, ac = 0, enc="", tmp_arr = [];

    if (!data) {
        return data;
    }

    data = this.utf8_encode(data+'');

    do { // pack three octets into four hexets
        o1 = data.charCodeAt(i++);
        o2 = data.charCodeAt(i++);
        o3 = data.charCodeAt(i++);

        bits = o1<<16 | o2<<8 | o3;

        h1 = bits>>18 & 0x3f;
        h2 = bits>>12 & 0x3f;
        h3 = bits>>6 & 0x3f;
        h4 = bits & 0x3f;

        // use hexets to index into b64, and append result to encoded string
        tmp_arr[ac++] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4);
    } while (i < data.length);

    enc = tmp_arr.join('');

    switch( data.length % 3 ){
        case 1:
            enc = enc.slice(0, -2) + '==';
        break;
        case 2:
            enc = enc.slice(0, -1) + '=';
        break;
    }

    return enc;
}

function utf8_encode ( argString ) {
    // Encodes an ISO-8859-1 string to UTF-8
    //
    // version: 905.1217
    // discuss at: http://phpjs.org/functions/utf8_encode
    // +   original by: Webtoolkit.info (http://www.webtoolkit.info/)
    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +   improved by: sowberry
    // +    tweaked by: Jack
    // +   bugfixed by: Onno Marsman
    // +   improved by: Yves Sucaet
    // +   bugfixed by: Onno Marsman
    // *     example 1: utf8_encode('Kevin van Zonneveld');
    // *     returns 1: 'Kevin van Zonneveld'
    var string = (argString+'').replace(/\r\n/g, "\n").replace(/\r/g, "\n");

    var utftext = "";
    var start, end;
    var stringl = 0;

    start = end = 0;
    stringl = string.length;
    for (var n = 0; n < stringl; n++) {
        var c1 = string.charCodeAt(n);
        var enc = null;

        if (c1 < 128) {
            end++;
        } else if((c1 > 127) && (c1 < 2048)) {
            enc = String.fromCharCode((c1 >> 6) | 192) + String.fromCharCode((c1 & 63) | 128);
        } else {
            enc = String.fromCharCode((c1 >> 12) | 224) + String.fromCharCode(((c1 >> 6) & 63) | 128) + String.fromCharCode((c1 & 63) | 128);
        }
        if (enc !== null) {
            if (end > start) {
                utftext += string.substring(start, end);
            }
            utftext += enc;
            start = end = n+1;
        }
    }

    if (end > start) {
        utftext += string.substring(start, string.length);
    }

    return utftext;
}

function utf8_decode ( str_data ) {
    // Converts a UTF-8 encoded string to ISO-8859-1
    //
    // version: 905.3122
    // discuss at: http://phpjs.org/functions/utf8_decode
    // +   original by: Webtoolkit.info (http://www.webtoolkit.info/)
    // +      input by: Aman Gupta
    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +   improved by: Norman "zEh" Fuchs
    // +   bugfixed by: hitwork
    // +   bugfixed by: Onno Marsman
    // +      input by: Brett Zamir (http://brett-zamir.me)
    // +   bugfixed by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // *     example 1: utf8_decode('Kevin van Zonneveld');
    // *     returns 1: 'Kevin van Zonneveld'
    var tmp_arr = [], i = 0, ac = 0, c1 = 0, c2 = 0, c3 = 0;

    str_data += '';

    while ( i < str_data.length ) {
        c1 = str_data.charCodeAt(i);
        if (c1 < 128) {
            tmp_arr[ac++] = String.fromCharCode(c1);
            i++;
        } else if ((c1 > 191) && (c1 < 224)) {
            c2 = str_data.charCodeAt(i+1);
            tmp_arr[ac++] = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));
            i += 2;
        } else {
            c2 = str_data.charCodeAt(i+1);
            c3 = str_data.charCodeAt(i+2);
            tmp_arr[ac++] = String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
            i += 3;
        }
    }

    return tmp_arr.join('');
}
</script>

base64_decode 依赖 utf8_decode ，base64_encode 依赖 utf8_encode。

PHP2JS是开源项目，是将PHP的部分函数实现到JavaScript。

这片子不错，北美影史春季档期，票房最高的一部影片。

片名：《速度与激情4》（Fast & Furious）赛车风云

主演：范·迪塞尔
　　　米歇尔·罗德里格兹
　　　保罗·沃克

类型：动作

上映：2009年4月3日

《速度与激情4》剧情介绍：

　　在经历了第4个篇章的故事洗礼之后，这套用速度与激情共同谱写的令人热血沸腾的赛车传奇，终于走向了终结......一切都结束于它开始的地方，即洛杉矶那肮脏凌乱、龙蛇混杂的街头，这里纯粹是一个属于男人的世界，既有蓄势待发的肌肉块头，也有养眼的极速美女，更别提遍布在大街小巷、色彩各异的改装赛车了--它们都已经进入了最佳的状态，时刻准备奔赴墨西哥的沙漠车道。

　　在第一集故事中就已然分道扬镳的一对好朋友，因为一个罪犯而再度聚首到了一起。两个人刚一打照面，出狱没多久的前帮派老大多米尼克·特莱托 (范·迪塞尔饰)的内心深处就再度燃起了对警探布莱恩·奥康纳(保罗·沃克饰)的熊熊怒火。然而，这一次他们却被迫去对抗一个共同的敌人--毒品贩子菲尼克斯·莱斯(拉泽·阿隆索饰)，所以只好暂时将所有的敌对与不和放在一边。多米尼克与布莱恩需要一起渗透进一个海洛因贩毒组织的内部做卧底，好掌握这里走私毒品的全部交易细节和证据，很快，他们就凭借出色的车技成为菲尼克斯最得力的两个手下......而多米尼克之所以会卷进来，不计前嫌地和布莱恩联手，完全是因为他刚刚获悉，菲尼克斯似乎就是害死自己恋人莱蒂(米歇尔·罗德里格兹饰)的罪魁祸首......

没有阿诺·施瓦辛格的《终结者2018》就是一部烂片。全篇都是大量的弹药浪费和复制变形金刚的大型机器人，终结者也沦落到了要复制别人的情节，可悲！终结者之父卡梅隆要被气死了，McG终究不够水准！

全国县域经济百强县公布 江苏27席江阴居首

新华网长沙7月26日电 （黄庭满）在此间召开的2009全国县域经济科学发展交流年会上，全国县域经济研究专门机构中郡县域经济研究所编制发布了第九届全国县域经济基本竞争力与科学发展评价报告，第九届全国县域经济基本竞争力百强县（市）名单也随之正式揭晓。

据了解，第九届全国县域经济基本竞争力与科学发展评价报告由中郡县域经济研究所历时一年跟踪研究编制，第九届全国县域经济基本竞争力百强县（市）名单也在此基础上完成。

第九届全国县域经济基本竞争力百强县（市）分布

根据报告，第九届全国县域经济基本竞争力百强县（市）分布在18个省（市、区）。具体分布如下:江苏省27个，浙江省26个，山东省 26个，福建省8个，河南省8个，河北省5个，辽宁省5个，湖南省4个，广东省2个，山西省2个，内蒙古自治区2个，江西省2个，陕西省2个，吉林省1 个，黑龙江省1个，上海市1个，四川省1个，新疆维吾尔自治区1个。

全国县域经济百强县（市）的平均规模是:人口82.95万人，地区生产总值367.26亿元，地方财政一般预算收入19.89亿元，人均地区生产总值为49080元，城镇居民人均可支配收入约17900元，农民人均纯收入约8470元，分别比上年增长0.75%、16.63%（当年价比，下同）、19.10%、16.52%、13.29%、11.59%。

全国县域经济百强县变化特征

根据报告，第九届全国县域经济基本竞争力百强县排序变化比较大。

全国县域经济百强县可以分老牌百强县和新兴百强县。老牌百强县出现分化，一部分已经成为中心城区经济的重要组成部分，另一部分发展相对较慢，退出百强县的行列。广东省百强县数目历史上曾达到15个之多，后来有6个改成市辖区，有7个退出百强县。

根据报告，新进第九届全国县域经济基本竞争力百强县（市）的有8个:河南永城市、湖南望城市、吉林延吉市、江苏句容市、江苏邳州市、江西贵溪市、山东博兴县、陕西靖边县。

新兴百强县具有以下特点:江苏省百强县由苏南向苏北"北上"；山东省百强县由胶东半岛向鲁中"西进"；中西部地区具有资源优势和区位优势的强县迅速崛起，现在中部地区已经崛起出16个全国百强县，西部地区已大开发出6个全国百强县；全国百强县的格局正在改变。

江苏、浙江、山东三省百强县对比

在第九届全国县域经济基本竞争力百强县（市）中，江苏、浙江、山东三省占的比例最大，各有特点。江苏县域经济规模大，百强县大而强，全国十强县中占有7席，特点是"集体经济+规模经营+资本市场"，区域统筹条件比较突出；浙江县域经济人口规模小，百强县相对富裕程度高、差别小，特点是" 民营经济+产业集群+专业市场"，城乡统筹条件比较突出；山东县域经济单位众多，差异性大，百强县突出性不足，特点是"政府主导+经济协作+多种模式"，区域经济协作比较突出。三省相比，山东省百强县的居民收入水平最低，百强县的相对富裕程度较弱，在发挥市场机制在县域经济的作用方面还有很大潜力。

在第九届评价中，江苏省百强县数量最多，百强县排序提升明显，20升7平；山东省百强县16升6平4降；浙江省百强县13升5平8降。