快捷導(dǎo)航

基于C#實(shí)現(xiàn)Json轉(zhuǎn)Lua的操作指南

更新時(shí)間：2024年12月19日 10:06:22 作者：兩水先木示

JSON（JavaScript Object Notation）是一種輕量級(jí)的數(shù)據(jù)交換格式,它的語(yǔ)法基于 JavaScript 對(duì)象表示法,簡(jiǎn)單、易讀,同時(shí)被許多編程語(yǔ)言支持,本文給大家介紹了如何基于C#實(shí)現(xiàn)Json轉(zhuǎn)Lua的操作指南,需要的朋友可以參考下

前提需引入NewtonsofJson，引入方法可先在Visual Studio 2019

將Newtonsoft.Json.dll文件導(dǎo)入U(xiǎn)nity的Plugins下。

Json格式字符串轉(zhuǎn)Lua格式字符串，效果如下：

json字符串

{
	"1": "asd",
	"2": true,
	"3": 1.5,
	"4": 123,
	"a": {
		"b": "c",
		"d": [1, 2, 3]
	}
}

lua字符串 (.lua文件一般直接return {}表故會(huì)加上 "return " 如果不需要可以自行修改代碼。)

return {
	[1] = "asd",
	[2] = true,
	[3] = 1.5,
	[4] = 123,
	a = {
		b = "c",
		d = { 1, 2, 3 }
	}
}

使用方法：

string json = "{\"1\":\"asd\",\"2\":true,\"3\":1.5,\"4\":123,\"a\":{\"b\":\"c\",\"d\":[1,2,3]}}";
string lua = Milk.Json.MilkJsonUtility.Json2Lua(json, true);

類說(shuō)明：

LuaObject：封裝Json基礎(chǔ)類型對(duì)象，核心GetString方法返回對(duì)象的字符串形式。
LuaTable：封裝JsonArray或JsonObject類型對(duì)象，主要是將數(shù)組或?qū)ο髢?nèi)的成員封裝為L(zhǎng)uaObject存儲(chǔ)起來(lái)，數(shù)組存儲(chǔ)于list，對(duì)象成員存儲(chǔ)于map，核心GetString方法返回表的字符串形式。
LuaTable類靜態(tài)方法：public static LuaTable CreateFromJson(string json)
由該方法進(jìn)行轉(zhuǎn)化json為lua，使用JObject.Parse(json)轉(zhuǎn)為Json對(duì)象，后經(jīng)過(guò)判斷是數(shù)組還是對(duì)象類型進(jìn)行使用不同函數(shù)轉(zhuǎn)化（JsonArray2LuaTable、JsonObject2LuaTable）
JsonArray2LuaTable：將Json數(shù)組成員一一轉(zhuǎn)化為L(zhǎng)uaTable
JsonObject2LuaTable：將Json對(duì)象成員一一轉(zhuǎn)化為L(zhǎng)uaTable

namespace Milk.Json
{
    public static class MilkJsonUtility
    {
        /// <summary>
        /// 將Json格式字符串轉(zhuǎn)成Lua表形式字符串
        /// </summary>
        /// <param name="json"></param>
        /// <param name="indented">是否縮進(jìn)</param>
        /// <returns></returns>
        public static string Json2Lua(string json, bool indented = false)
        {
            var table = LuaTable.CreateFromJson(json);
            return $"return {table.GetString(indented)}";
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Milk.Json
{
    public enum LuaValueType
    {
        Table,
        String,
        Num,
        Boolean,
        nil
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using Newtonsoft.Json.Linq;
 
namespace Milk.Json
{
    public class LuaTable
    {
        //存放table中的有序部分
        private List<LuaObject> list = new List<LuaObject>();
 
        //存放table中的無(wú)序部分
        private Dictionary<string, LuaObject> map = new Dictionary<string, LuaObject>();
 
        //所在層級(jí)
        private int layer = 0;
 
        public LuaTable(int _layer)
        {
            layer = _layer + 1;
        }
 
        #region 有序數(shù)組添加
 
        /// <summary>
        /// [有序]添加string value
        /// </summary>
        /// <param name="value"></param>
        public void AddItem(string value)
        {
            list.Add(new LuaObject(value));
        }
 
        /// <summary>
        /// [有序]num value
        /// </summary>
        /// <param name="value"></param>
        public void AddItem(int value)
        {
            list.Add(new LuaObject(value));
        }
 
        /// <summary>
        /// [有序]num value
        /// </summary>
        /// <param name="value"></param>
        public void AddItem(float value)
        {
            list.Add(new LuaObject(value));
        }
 
        /// <summary>
        /// [有序]bool value
        /// </summary>
        /// <param name="value"></param>
        public void AddItem(bool value)
        {
            list.Add(new LuaObject(value));
        }
 
        public void AddItem(LuaTable value)
        {
            list.Add(new LuaObject(value));
        }
 
        /// <summary>
        /// 加入nil
        /// </summary>
        public void AddItemNil()
        {
            list.Add(new LuaObject());
        }
 
        #endregion
 
 
        #region Key_Value添加
 
        public void AddItem(string key, string value)
        {
            //查重
            if (!map.ContainsKey(key))
            {
                map.Add(key, new LuaObject(value));
            }
        }
 
        public void AddItem(string key, int value)
        {
            //查重
            if (!map.ContainsKey(key))
            {
                map.Add(key, new LuaObject(value));
            }
        }
 
        public void AddItem(string key, float value)
        {
            //查重
            if (!map.ContainsKey(key))
            {
                map.Add(key, new LuaObject(value));
            }
        }
 
        public void AddItem(string key, bool value)
        {
            //查重
            if (!map.ContainsKey(key))
            {
                map.Add(key, new LuaObject(value));
            }
        }
 
        public void AddItem(string key, LuaTable value)
        {
            //查重
            if (!map.ContainsKey(key))
            {
                map.Add(key, new LuaObject(value));
            }
        }
 
        public void AddItemNil(string key)
        {
            //查重
            if (!map.ContainsKey(key))
            {
                map.Add(key, new LuaObject());
            }
        }
 
        #endregion
 
        private bool IsNumeric(string str)
        {
            int number;
            return int.TryParse(str, out number);
        }
 
        private string IndentedLayer(string str, bool indented, int change = 0)
        {
            if (indented)
            {
                for (int i = 0; i < layer + change; i++)
                {
                    str = "\t" + str;
                }
            }
            return str;
        }
 
        public string GetString(bool indented = false)
        {
            string str = "{";
            bool hasList = list.Count > 0;
            bool hasMap = map.Count > 0;
            bool isNeedIndented = false;
            if (indented && (hasList || hasMap))
            {
                isNeedIndented = true;
                if (hasList)
                {
                    LuaValueType type = list[0].GetLuaValueType();
                    if (type == LuaValueType.Boolean || type == LuaValueType.Num)
                    {
                        isNeedIndented = false;
                    }
                }
                if (isNeedIndented)
                    str += "\n";
            }
            if (hasList)
            {
                int count = 0;
                foreach (var item in list)
                {
                    count++;
                    if (!isNeedIndented)
                    {
                        if (indented && count == 1)
                            str += " ";
                        str += item.GetString(indented);
                        if (count < list.Count)
                            str += ",";
                        if (indented)
                            str += " ";
                    }
                    else
                    {
                        str += IndentedLayer(item.GetString(indented), indented);
                        if (count < list.Count)
                            str += ",";
                        if (indented)
                            str += "\n";
                    }
                }
            }
 
            if (hasMap)
            {
                int count = 0;
                foreach (var item in map)
                {
                    count++;
                    var key = item.Key.Replace('$', '_');
                    if (IsNumeric(key))
                    {
                        key = $"[{key}]";
                    }
                    if (indented)
                        str += IndentedLayer($"{key} = {item.Value.GetString(indented)}", indented);
                    else
                        str += IndentedLayer($"{key}={item.Value.GetString(indented)}", indented);
                    if (count < map.Count)
                        str += ",";
                    if (indented)
                        str += "\n";
                }
            }
 
            if (!isNeedIndented)
            {
                str += "}";
            }
            else
            {
                str += IndentedLayer("}", indented, -1);
            }
 
            return str;
        }
 
        public static LuaTable CreateFromJson(string json)
        {
            var jsonObject = JObject.Parse(json);
            if (jsonObject.Type == JTokenType.Array)
            {
                return JsonArray2LuaTable(jsonObject.ToObject<JArray>(), 0);
            }
            else
            {
                return JsonObject2LuaTable(jsonObject, 0);
            }
        }
 
        /// <summary>
        /// 遞歸方法
        /// </summary>
        static LuaTable JsonObject2LuaTable(JObject jsonObj, int layer)
        {
            var curLuaTable = new LuaTable(layer);
 
            //構(gòu)建無(wú)序Table(lua表 key-value形式)
            foreach (var item in jsonObj)
            {
                switch (item.Value.Type)
                {
                    case JTokenType.Boolean:
                        curLuaTable.AddItem(item.Key, (bool)item.Value);
                        break;
                    case JTokenType.Array:
                        curLuaTable.AddItem(item.Key, JsonArray2LuaTable(item.Value.ToObject<JArray>(), layer + 1));
                        break;
                    case JTokenType.String:
                        curLuaTable.AddItem(item.Key, (string)item.Value);
                        break;
                    case JTokenType.Date: //轉(zhuǎn)成string
                        curLuaTable.AddItem(item.Key, (string)item.Value);
                        break;
                    case JTokenType.Float:
                        curLuaTable.AddItem(item.Key, (float)item.Value);
                        break;
                    case JTokenType.Integer:
                        curLuaTable.AddItem(item.Key, (int)item.Value);
                        break;
                    case JTokenType.None:
                        curLuaTable.AddItemNil(item.Key);
                        break;
                    case JTokenType.Null:
                        curLuaTable.AddItemNil(item.Key);
                        break;
                    case JTokenType.Object:
                        curLuaTable.AddItem(item.Key, JsonObject2LuaTable(item.Value.ToObject<JObject>(), layer + 1));
                        break;
                    case JTokenType.TimeSpan:
                        curLuaTable.AddItem(item.Key, (float)item.Value);
                        break;
                }
            }
 
            return curLuaTable;
        }
 
        static LuaTable JsonArray2LuaTable(JArray jsonArray, int layer)
        {
            var curLuaTable = new LuaTable(layer);
            //構(gòu)建有序Table(lua表)
            foreach (var item in jsonArray)
            {
                //檢查子項(xiàng)類型
                switch (item.Type)
                {
                    case JTokenType.Boolean:
                        curLuaTable.AddItem((bool)item);
                        break;
                    case JTokenType.Array:
                        curLuaTable.AddItem(JsonArray2LuaTable(item.ToObject<JArray>(), layer + 1));
                        break;
                    case JTokenType.String:
                        curLuaTable.AddItem((string)item);
                        break;
                    case JTokenType.Object:
                        curLuaTable.AddItem(JsonObject2LuaTable(item.ToObject<JObject>(), layer + 1));
                        break;
                    case JTokenType.Date:
                        curLuaTable.AddItem((string)item);
                        break;
                    case JTokenType.Float:
                        curLuaTable.AddItem((float)item);
                        break;
                    case JTokenType.Integer:
                        curLuaTable.AddItem((int)item);
                        break;
                    case JTokenType.None:
                        curLuaTable.AddItemNil();
                        break;
                    case JTokenType.Null:
                        curLuaTable.AddItemNil();
                        break;
                    case JTokenType.TimeSpan:
                        curLuaTable.AddItem((float)item);
                        break;
                }
            }
 
            return curLuaTable;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
 
namespace Milk.Json
{
    public class LuaObject
    {
        private LuaValueType type;
 
        private float valueNumber;
        private string valueString;
        private bool valueBoolean;
        private LuaTable valueTable;
 
        public LuaObject(string value)
        {
            type = LuaValueType.String;
            valueString = value;
        }
 
        public LuaObject(float value)
        {
            type = LuaValueType.Num;
            valueNumber = value;
        }
 
        public LuaObject(int value)
        {
            type = LuaValueType.Num;
            valueNumber = value;
        }
 
        public LuaObject(bool value)
        {
            type = LuaValueType.Boolean;
            valueBoolean = value;
        }
 
        public LuaObject(LuaTable value)
        {
            type = LuaValueType.Table;
            valueTable = value;
        }
 
        public LuaObject()
        {
            type = LuaValueType.nil;
        }
 
        public string GetString(bool indented = false)
        {
            switch (type)
            {
                case LuaValueType.Table:
                    return valueTable.GetString(indented);
                //break;
                case LuaValueType.Boolean:
                    if (valueBoolean)
                    {
                        return "true";
                    }
                    else
                    {
                        return "false";
                    }
                //break;
                case LuaValueType.Num:
                    return valueNumber.ToString();
                //break;
                case LuaValueType.String:
                    return "\""+ valueString+"\"";
                case LuaValueType.nil:
                    return "nil";
                default:
                    return "";
            }
        }
 
        public LuaValueType GetLuaValueType()
        {
            return type;
        }
    }
}

到此這篇關(guān)于基于C#實(shí)現(xiàn)Json轉(zhuǎn)Lua的操作指南的文章就介紹到這了,更多相關(guān)C# Json轉(zhuǎn)Lua內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: