PHP 序列化和反序列化 for ActionScript 3.0

最新推荐文章于 2022-02-25 20:00:37 发布
最新推荐文章于 2022-02-25 20:00:37 发布
阅读量106 收藏
点赞数
分类专栏： Flash/as3 文章标签： ActionScript PHP phprpc Flash C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxyskycn/article/details/83488333
版权

Serializable.as

ActionScript代码 
/**********************************************************\  
|                                                          |  
| The implementation of PHPRPC Protocol 3.0                |  
|                                                          |  
| Serializable.as                                          |  
|                                                          |  
| Release 3.0.0                                            |  
| Copyright (c) 2005-2007 by Team-PHPRPC                   |  
|                                                          |  
| WebSite:  http://www.phprpc.org/                         |  
|           http://www.phprpc.net/                         |  
|           http://www.phprpc.com/                         |  
|           http://sourceforge.net/projects/php-rpc/       |  
|                                                          |  
| Authors:  Ma Bingyao <andot@ujn.edu.cn>                  |  
|                                                          |  
| This file may be distributed and/or modified under the   |  
| terms of the GNU Lesser General Public License (LGPL)    |  
| version 3.0 as published by the Free Software Foundation |  
| and appearing in the included file LICENSE.              |  
|                                                          |  
\**********************************************************/   
   
/* Serializable interface for custom PHP serialize.  
 *  
 * Copyright (C) 2006-2007 Ma Bingyao <andot@ujn.edu.cn>  
 * Version: 3.0  
 * LastModified: Oct 23, 2007  
 * This library is free.  You can redistribute it and/or modify it.  
 */   
   
package org.phprpc.util{   
    import flash.utils.ByteArray;   
    public interface Serializable {   
        function serialize():ByteArray;   
        function unserialize(ss:ByteArray):void;   
    }   
}
 

PHPSerializer.as

ActionScript代码 
/**********************************************************\  
|                                                          |  
| The implementation of PHPRPC Protocol 3.0                |  
|                                                          |  
| PHPSerializer.as                                         |  
|                                                          |  
| Release 3.0.0                                            |  
| Copyright (c) 2005-2007 by Team-PHPRPC                   |  
|                                                          |  
| WebSite:  http://www.phprpc.org/                         |  
|           http://www.phprpc.net/                         |  
|           http://www.phprpc.com/                         |  
|           http://sourceforge.net/projects/php-rpc/       |  
|                                                          |  
| Authors:  Ma Bingyao <andot@ujn.edu.cn>                  |  
|                                                          |  
| This file may be distributed and/or modified under the   |  
| terms of the GNU Lesser General Public License (LGPL)    |  
| version 3.0 as published by the Free Software Foundation |  
| and appearing in the included file LICENSE.              |  
|                                                          |  
\**********************************************************/   
/* PHP serialize/unserialize library for ActionScript 3.0.  
 *  
 * Copyright (C) 2006-2007 Ma Bingyao <andot@ujn.edu.cn>  
 * Version: 3.0  
 * LastModified: Nov 6, 2007  
 * This library is free.  You can redistribute it and/or modify it.  
 */   
package org.phprpc.util {   
    import org.phprpc.util.Serializable;   
    import flash.utils.ByteArray;   
    import flash.utils.Dictionary;   
    import flash.utils.getQualifiedClassName;   
    import flash.utils.getDefinitionByName;   
    public class PHPSerializer {   
        private static function isInteger(s:String):Boolean {   
            var i:int;   
            var l:int = s.length;   
            if (l > 11) {   
                return false;   
            }   
            for (i = (s.charAt(0) == '-') ? 1 : 0; i < l; i++) {   
                switch (s.charAt(i)) {   
                case '0' :   
                case '1' :   
                case '2' :   
                case '3' :   
                case '4' :   
                case '5' :   
                case '6' :   
                case '7' :   
                case '8' :   
                case '9' :   
                    break;   
                default :   
                    return false;   
                }   
            }   
            var n:Number = Number(s);   
            return !(n < -2147483648 || n > 2147483647);   
        }   
        public static function getClassName(o:*):String {   
            var className:String = getQualifiedClassName(o);   
            return className.replace(/\./g, '_').replace(/\:\:/g, '_');   
        }   
        private static function getObjectOfClass(cn:Array, poslist:Array, i:uint, c:String):Object {   
            if (i < poslist.length) {   
                var pos:uint = poslist[i];   
                cn[pos] = c;   
                var obj:Object = getObjectOfClass(cn, poslist, i + 1, '.');   
                if (i + 1 < poslist.length) {   
                    if (obj == null) {   
                        obj = getObjectOfClass(cn, poslist, i + 1, '_');   
                    }   
                }   
                return obj;   
            }   
            var classname:String = cn.join('');   
            try {   
                return new (flash.utils.getDefinitionByName(classname) as Class);   
            }   
            catch (e:Error) { };   
            return null;   
        }   
        public static function createObjectOfClass(classname:String):Object {   
            try {   
                return new (flash.utils.getDefinitionByName(classname) as Class);   
            }   
            catch (e:Error) {}   
            var poslist:Array = [];   
            var pos:int = classname.indexOf("_");   
            while (pos > -1) {   
                poslist[poslist.length] = pos;   
                pos = classname.indexOf("_", pos + 1);   
            }   
            if (poslist.length > 0) {   
                var cn:Array = classname.split('');   
                var obj:Object = getObjectOfClass(cn, poslist, 0, '.');   
                if (obj == null) {   
                    obj = getObjectOfClass(cn, poslist, 0, '_');   
                }   
                if (obj != null) {   
                    return obj;   
                }   
            }   
            return {name:classname};   
        }   
        public static function serialize(o:Object):ByteArray {   
            var sb:ByteArray = new ByteArray();   
            var ht:Dictionary = new Dictionary();   
            var hv:uint = 1;   
            function _serializeNull():void {   
                sb.writeUTFBytes('N;');   
            }   
            function _serializeBoolean(b:Boolean):void {   
                sb.writeUTFBytes(b ? 'b:1;' : 'b:0;');   
            }   
            function _serializeInteger(i:int):void {   
                sb.writeUTFBytes('i:' + i + ';');   
            }   
            function _serializeDouble(d:Number):void {   
                var s:String;   
                if (isNaN(d)) {   
                    s = 'NAN';   
                }   
                else if (d == Number.POSITIVE_INFINITY) {   
                    s = 'INF';   
                }   
                else if (d == Number.NEGATIVE_INFINITY) {   
                    s = '-INF';   
                }   
                else {   
                    s = d.toString(10);   
                }   
                sb.writeUTFBytes('d:' + s + ';');   
            }   
            function _serializeByteArray(ba:ByteArray):void {   
                ba.position = 0;   
                sb.writeUTFBytes('s:' + ba.length + ':"');   
                sb.writeBytes(ba);   
                sb.writeUTFBytes('";');                
            }   
            function _serializeString(s:String):void {   
                var utf8:ByteArray = new ByteArray();   
                utf8.writeUTFBytes(s);   
                sb.writeUTFBytes('s:' + utf8.length + ':"');   
                sb.writeBytes(utf8);   
                sb.writeUTFBytes('";');   
            }   
            function _serializeDate(dt:Date):void {   
                sb.writeUTFBytes('O:11:"PHPRPC_Date":7:{');   
                sb.writeUTFBytes('s:4:"year";');   
                _serializeInteger(dt.getFullYear());   
                sb.writeUTFBytes('s:5:"month";');   
                _serializeInteger(dt.getMonth() + 1);   
                sb.writeUTFBytes('s:3:"day";');   
                _serializeInteger(dt.getDate());   
                sb.writeUTFBytes('s:4:"hour";');   
                _serializeInteger(dt.getHours());   
                sb.writeUTFBytes('s:6:"minute";');   
                _serializeInteger(dt.getMinutes());   
                sb.writeUTFBytes('s:6:"second";');   
                _serializeInteger(dt.getSeconds());   
                sb.writeUTFBytes('s:11:"millisecond";');   
                _serializeInteger(dt.getMilliseconds());   
                sb.writeUTFBytes('}');   
            }   
            function _serializeArray(a:Object):void {   
                var k:String;   
                var l:uint = 0;   
                for (k in a) l++;   
                sb.writeUTFBytes('a:' + l + ':{');   
                for (k in a) {   
                    if (typeof (a[k]) != 'function') {   
                        isInteger(k) ? _serializeInteger(k) : _serializeString(k);   
                        _serialize(a[k]);   
                    }   
                }   
                sb.writeUTFBytes('}');   
            }   
            function _serializeObject(o:Object, cn:String):void {   
                var c:Serializable = o as Serializable;   
                var cnb:ByteArray = new ByteArray();   
                cnb.writeUTFBytes(cn);   
                if (c == null) {   
                    sb.writeUTFBytes('O:' + cnb.length + ':"');   
                    sb.writeBytes(cnb);   
                    var k:String;   
                    var l:uint = 0;   
                    for (k in o) l++;   
                    sb.writeUTFBytes('":' + l + ':{');                     
                    for (k in o) {   
                        if (typeof(o[k]) != 'function') {   
                            _serializeString(k);   
                            _serialize(o[k]);   
                        }   
                    }   
                    sb.writeUTFBytes('}');   
                }   
                else {   
                    var data:ByteArray = c.serialize();   
                    sb.writeUTFBytes('C:' + cnb.length + ':"');   
                    sb.writeBytes(cnb);   
                    sb.writeUTFBytes('":' + data.length + ':{');   
                    sb.writeBytes(data);   
                    sb.writeUTFBytes('}');   
                }   
            }   
            function _serializePointRef(R:uint):void {   
                sb.writeUTFBytes('R:' + R + ';');   
            }   
            function _serializeRef(r:uint):void {   
                sb.writeUTFBytes('r:' + r + ';');   
            }   
            function _serialize(o:*):void {   
                if (typeof (o) == "undefined" || o == null || o.constructor == Function) {   
                    hv++;   
                    _serializeNull();   
                    return;   
                }   
                var className:String = getClassName(o);   
                switch (o.constructor) {   
                case Boolean :   
                    hv++;   
                    _serializeBoolean(o);   
                    break;   
                case Number :   
                    hv++;   
                    isInteger(o) ? _serializeInteger(o) : _serializeDouble(o);   
                    break;   
                case String :   
                    hv++;   
                    _serializeString(o);   
                    break;   
                case ByteArray :   
                    hv++;   
                    _serializeByteArray(o);   
                    break;   
                case Date :   
                    hv++;   
                    _serializeDate(o);   
                    break;   
                default :   
                    var r:int = ht[o];   
                    if (className == "Object" || o.constructor == Array) {   
                        if (r) {   
                            _serializePointRef(r);   
                        }   
                        else {   
                            ht[o] = hv++;   
                            _serializeArray(o);   
                        }   
                    }   
                    else {   
                        if (r) {   
                            hv++;   
                            _serializeRef(r);   
                        }   
                        else {   
                            ht[o] = hv++;   
                            _serializeObject(o, className);   
                        }                      
                    }   
                    break;   
                }   
            }   
            _serialize(o);   
            return sb;   
        }   
        public static function unserialize(sb:ByteArray):* {   
            var ht:Dictionary = new Dictionary();   
            var hv:int = 1;   
            function _readNumber():String {   
                var s:String = '';   
                var c:String = sb.readUTFBytes(1);   
                while ((c != ';') && (c != ':')) {   
                    s += c;   
                    c = sb.readUTFBytes(1);   
                }   
                return s;   
            }   
            function _unserializeNull():Object {   
                sb.position++;   
                return null;   
            }   
            function _unserializeBoolean():Boolean {   
                sb.position++;   
                var b:Boolean = (sb.readUTFBytes(1) == '1');   
                sb.position++;   
                return b;   
            }   
            function _unserializeInteger():int {   
                sb.readByte();   
                var i:int = parseInt(_readNumber());   
                return i;   
            }   
            function _unserializeDouble():Number {   
                sb.position++;   
                var d:Number;   
                var s:String = _readNumber();   
                switch (s) {   
                case 'NAN' :   
                    d = Number.NaN;   
                    break;   
                case 'INF' :   
                    d = Number.POSITIVE_INFINITY;   
                    break;   
                case '-INF' :   
                    d = Number.NEGATIVE_INFINITY;   
                    break;   
                default :   
                    d = parseFloat(s);   
                }   
                return d;   
            }   
            function _unserializeByteArray():ByteArray {   
                sb.position++;   
                var l:uint = parseInt(_readNumber());   
                sb.position++;   
                var ba:ByteArray = new ByteArray();   
                if (l > 0) {   
                    sb.readBytes(ba, 0, l);   
                }   
                sb.position += 2;   
                return ba;   
            }   
            function _unserializeString():String {   
                sb.position++;   
                var l:uint = parseInt(_readNumber());   
                sb.position++;   
                var s:String = sb.readUTFBytes(l);   
                sb.position += 2;   
                return s;   
            }   
            function _unserializeEscapedString(len:int):String {   
                sb.position++;   
                var l:uint = parseInt(_readNumber());   
                sb.position++;   
                var i:int;   
                var s:Array = new Array(l);   
                for (i = 0; i < l; i++) {   
                    if ((s[i] = sb.readUTFBytes(1)) == '\\') {   
                        s[i] = String.fromCharCode(parseInt(sb.readUTFBytes(len), 16));   
                    }   
                }   
                sb.position += 2;   
                return s.join('');   
            }   
            function _unserializeArray():Array {   
                sb.position++;   
                var n:int = parseInt(_readNumber());   
                sb.position++;   
                var i:int;   
                var k:*;   
                var a:Array = [];   
                ht[hv++] = a;   
                for (i = 0; i < n; i++) {   
                    switch (sb.readUTFBytes(1)) {   
                    case 'i' :   
                        k = _unserializeInteger();   
                        break;   
                    case 's' :   
                        k = _unserializeString();   
                        break;   
                    case 'S' :   
                        k = _unserializeEscapedString(2);   
                        break;   
                    case 'U' :   
                        k = _unserializeEscapedString(4);   
                        break;   
                    default :   
                        return null;   
                    }   
                    a[k] = _unserialize();   
                }   
                sb.position++;   
                return a;   
            }   
            function _unserializeDate(n:int):Date {   
                var i:int;   
                var k:String;   
                var a:Object = {};   
                for (i = 0; i < n; i++) {   
                    switch (sb.readUTFBytes(1)) {   
                    case 's' :   
                        k = _unserializeString();   
                        break;   
                    case 'S' :   
                        k = _unserializeEscapedString(2);   
                        break;   
                    case 'U' :   
                        k = _unserializeEscapedString(4);   
                        break;   
                    default :   
                        return null;   
                    }   
                    if (sb.readUTFBytes(1) == 'i') {   
                        a[k] = _unserializeInteger();   
                    }   
                    else {   
                        return null;   
                    }   
                }   
                sb.position++;   
                var dt:Date = new Date(a.year, a.month - 1, a.day, a.hour, a.minute, a.second, a.millisecond);   
                ht[hv++] = dt;   
                return dt;   
            }   
            function _unserializeObject():* {   
                sb.position++;   
                var l:uint = parseInt(_readNumber());   
                sb.position++;   
                var cn:String = sb.readUTFBytes(l);   
                sb.position += 2;   
                var n:uint = parseInt(_readNumber());   
                sb.position++;   
                if (cn == "PHPRPC_Date") {   
                    return _unserializeDate(n);   
                }   
                var i:int;   
                var k:String;   
                var o:Object = createObjectOfClass(cn);   
                ht[hv++] = o;   
                for (i = 0; i < n; i++) {   
                    switch (sb.readUTFBytes(1)) {   
                    case 's' :   
                        k = _unserializeString();   
                        break;   
                    case 'S' :   
                        k = _unserializeEscapedString(2);   
                        break;   
                    case 'U' :   
                        k = _unserializeEscapedString(4);   
                        break;   
                    default :   
                        return false;   
                    }   
                    if (k.charAt(0) == '\0') {   
                        k = k.substring(k.indexOf('\0', 1) + 1, k.length);   
                    }   
                    o[k] = _unserialize();   
                }   
                sb.position++;   
                return o;   
            }   
            function _unserializeCustomObject():* {   
                sb.position++;   
                sb.position++;   
                var l:uint = parseInt(_readNumber());   
                sb.position++;   
                var cn:String = sb.readUTFBytes(l);   
                sb.position += 2;   
                var n:uint = parseInt(_readNumber());   
                sb.position++;   
                var data:ByteArray = new ByteArray();   
                sb.readBytes(data, 0, n);   
                sb.position++;   
                var o:Object = createObjectOfClass(cn);   
                var c:Serializable = o as Serializable;   
                if (c == null) {   
                    o.data = data;   
                    return o;   
                }   
                c.unserialize(data);   
                return c;   
            }   
            function _unserializeRef():* {   
                sb.position++;   
                var r:uint = parseInt(_readNumber());   
                return ht[r];   
            }   
            function _unserialize():* {   
                var result:*;   
                switch (sb.readUTFBytes(1)) {   
                case 'N' :   
                    result = _unserializeNull();   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 'b' :   
                    result = _unserializeBoolean();   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 'i' :   
                    result = _unserializeInteger();   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 'd' :   
                    result = _unserializeDouble();   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 's' :   
                    result = _unserializeByteArray();   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 'S' :   
                    result = _unserializeEscapedString(2);   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 'U' :   
                    result = _unserializeEscapedString(4);   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 'r' :   
                    result = _unserializeRef();   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 'a' :   
                    return _unserializeArray();   
                case 'O' :   
                    return _unserializeObject();   
                case 'C' :   
                    return _unserializeCustomObject();   
                case 'R' :   
                    return _unserializeRef();   
                }   
                return false;   
            }   
            sb.position = 0;   
            return _unserialize();   
        }   
    }   
}
 
zxyskycn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PHPSerializer.java
06-17
php的serialize/unserialize，方便把一个数组序列化和反序列化，但是要和java交互，就比较麻烦了。通过这个工具类可实现很好的php与java的交互。 博客地址：https://blog.csdn.net/u011582840/article/details/92650656，可以查看如何使用
php-serializer:用于快速操作大型序列化数组的库
06-22
PHP序列化程序 该库正在进行中。 在使用phpunit之前测试任何构建。 用于快速操作大型序列化字符串的库， PHPSerializer 旨在提高的效率 在 PHP 中，如果您有一个序列化数组，并且希望向该数组添加一个项目，则需要执行以下操作： $data = unserialize($serialized); array_push($data, 'some-new-item'); $serialized = unserialize($data); 这有什么问题？ 好吧，为这样一个简单的操作反序列化整个数组是非常低效的。 如果您正在反序列化一个小数组或者您不经常这样做，那么这可能没问题，但如果您处于重负载设置中，则必须有更好的方法。 PHPSerializer 背后的想法本质上是根据操作以最有效的方式解析和流式传输序列化的字符串，而不是unserialize()为每个函数处理
java反序列化 （PHPSerializer 序列化的对象）
Henry_Lin_Wind的博客
04-07 2874
java反序列化php序列化的对象 1、原始数据为一个字符串 2、原始数据为一个对象 3、原始数据为一个集合（List 或Map） 1、反序列化为java字符串 s:21:"这是一个字符串"; String str = "s:21:\"这是一个字符串\""; PHPSerializer phpSerializer = new PHPSerializer(); Object o...
java php序列化_java 反序列化PHP
weixin_36068796的博客
02-12 160
由于本人所在开发的项目，前期是由php完成的，这里需要对数据库中php序列化的字符串进行反序列化。1、引入maven依赖org.sctionphprpc3.0.22、反序列化对象方法public static Test getUnserialize(String content) throws Exception {PHPSerializer p = new PHPSerializer();if ...
phprpc.jar 包java 反序列化PHP工程demo
03-30
java 反序列化PHP ,java解析php序列化的字符串，工具包和工程实例
ActionScript3.0 对象序列化
04-26
如果你需要获得ActionScript3.0对象序列化方面的代码样例，你应该下载该文档。
Hprose for php-PHP
06-20
它提供了高效的序列化和反序列化库，并在此基础上提供了方便灵活的RPC引擎。 Hprose支持众多编程语言，例如： AAuto Quicker ActionScript ASP C++ Dart Delphi/Free Pascal dotNET(C#, Visual Basic...) Golang ...
Modi:AS3 MVC 模型库，用于通过序列化和观察来定义应用程序数据
07-07
模型定义存储为文本文件，易于阅读和维护。 使用简单的 Python 脚本，将数据转换为易于监控的 Actionscript 类。 要求 演示示例 演示/src/Player.yaml Player: name: String commanders: ManagedArray gold:...
nexuslib-as3:一个Actionscript库，提供强大的反射，序列化，种子随机数生成，加密，联网等功能
05-18
枚举，随机，反射，序列化，加密，音频系统，HTTP请求。 反射库专门用于生产环境，目前正在生产环境中使用。 入门 下载，或在您的项目中克隆仓库和参考。 外部依赖 没有任何 blooddy-crypto与nexuslib.swc静态链接...
Flex 对象持久化
10-29
总有人问我关于Flex对象序列化和持久化的问题，很多人认为对象不能拷贝到服务器，其实浅度的拷贝是可以做到的。
java 序列化成PHP格式。
08-18
将java数据 序列化成PHP的格式 a:4:{s:6:"title2";s:13:"这是标题2";s:6:"title3";s:13:"这是标题3";s:5:"title";s:13:"这是标题1";s:6:"title4";s:13:"这是标题4";} 或者a:1:{i:0;a:1:{s:4:"name";s:10:"这是1321";}}等其他类型
java序列化对象传给php
01-17
android(包括java)序列化一个对象传给php去做处理,或是接到php的序列化的对象在java中做处理的工具jar包以及使用方法. 使用方法: byte[] b = null; b = PHPSerializer.serialize(一个对象);//将一个对象序列化后返回byte[] String phpserialstr=new String(b); 将变量phpserialstr传给php即可. PHPSerializer中还有unserialize方法,是反序列化
java反序列化 PHPSerializer 序列化的对象参数描述
一起进步的博客
07-01 839
maven 引用的包 <!--反序列化 php--> <dependency> <groupId>org.sction</groupId> <artifactId>phprpc</artifactId> <version>3.0.2</version> </dependency 主要的操作方法： public static Map<String, Ob
Unity 【Content Size Fitter】- 聊天气泡自动适配Text文本框大小
当代野生程序猿
02-25 5315
通常在展示人物对话的时候文本的长度是不定的，因此会需要动态的调整对话内容文本框的背景图片的大小，这里以如下这种气泡框的对话为例： 实现该需求涉及到的内容包括Content Size Fitter组件的使用、2D Sprite工具包的使用。 Content Size Fitter组件用于Text文本框，如图所示，我们将Horzontal Fit设为Preferred Size，当我们调整Text文本框中的内容时，其大小会自动进行调整。 注意Rect Transform中Pivot轴心点的设置
新唐NUC972 Linux（一）：USB烧写linux出厂镜像
小破孩的博客
02-20 2952
USB烧写出厂镜像 文章目录USB烧写出厂镜像前言一、硬件连接二、安装驱动三、烧写linux程序四、运行程序 前言 今天开始进军linux，学了那么久单片机，也摸得七七八八，至少点个灯还是会的。本人之所以买酷客的linux开发板主要是便宜，资料也算齐全，虽然没有原子那么好，不过也够了，找那么多借口，其实就是qiong。今天先从USB烧录官方提供的linux相关程序到芯片开始吧。 一、硬件连接 1、连接电源线 2、RS232转USB，需要安装CH340驱动，用于在电脑串口超级终端中查看调试信息。 3、U
WeChall CTF Writeup（一）
weixin_43211186的博客
02-25 1197
以下题目标题组成： [Score] [Title] [Author] 文章目录0x01 1 Training: Get Sourced by Gizmore0x02 1 Training: Stegano I by Gizmore0x03 1 Training: Crypto - Caesar I by Gizmore0x04 1 Training: WWW-Robots by Gizmore0x05 1 Training: ASCII by Gizmore 0x01 1 Training: Get Sou
C语言每日一练——第126天：佩奇借书问题
热门推荐
Edison's 小宇宙
02-25 2万+
史上最强借书方案问题讲解（代码详解+思路分析+动图演示+特性总结）
CS5261与CS5265功能应用|CS5261替代RTD2171|CS5265替代RTD2172
qq1659747718的博客
02-25 1115
CS5261可以完全替代兼容停产RTD2171,CS5265可以完全替代兼容RTD2172，芯片单价低，整体方案设计简单，整体BOM成本较RTD2171、RTD2172低。
Hello Kafka（八）——Confluent Kafka简介
天山老妖
02-24 8600
一、Confluent Kafka简介 1、Confluent Kafka简介 2014年，Kafka的创始人Jay Kreps、NahaNarkhede和饶军离开LinkedIn创立Confluent公司，专注于提供基于Kafka的企业级流处理解决方案，并发布了Confluent Kafka。Confluent Kafka分为开源版和企业版，企业版收费。 2、Confluent Kafka特性 Confluent Kafka开源版特性如下： （1）Confluent Kafka Connecto
actionscript 3.0 游戏开发
最新发布
12-17
首先，ActionScript 3.0 具有面向对象编程的特性，如封装、继承和多态，这使得游戏开发更加灵活和可扩展。你可以创建各种类型的游戏对象，并根据需要设定它们的属性和行为。 其次，ActionScript 3.0 提供了丰富的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值