tnblog
首页
视频
资源
登录

来!!!今天玩 json

2612人阅读 2018/12/12 20:26 总访问:31208 评论:0 收藏:0 手机
分类: json


             别怪我懒,其实我是真的懒

  1. /// <summary>
  2.         /// List转成json 
  3.         /// </summary>
  4.         /// <typeparam name="T"></typeparam>
  5.         /// <param name="jsonName"></param>
  6.         /// <param name="list"></param>
  7.         /// <returns></returns>
  8.         public static string ListToJson<T>(IList<T> list, string jsonName)
  9.         {
  10.             StringBuilder Json = new StringBuilder();
  11.             if (string.IsNullOrEmpty(jsonName))
  12.                 jsonName = list[0].GetType().Name;
  13.             Json.Append("{\"" + jsonName + "\":[");
  14.             if (list.Count > 0)
  15.             {
  16.                 for (int i = 0; i < list.Count; i++)
  17.                 {
  18.                     T obj = Activator.CreateInstance<T>();
  19.                     PropertyInfo[] pi = obj.GetType().GetProperties();
  20.                     Json.Append("{");
  21.                     for (int j = 0; j < pi.Length; j++)
  22.                     {
  23.                         Type type;
  24.                         object o = pi[j].GetValue(list[i], null);
  25.                         string v = string.Empty;
  26.                         if (o != null)
  27.                         {
  28.                             type = o.GetType();
  29.                             v = o.ToString();
  30.                         }
  31.                         else
  32.                         {
  33.                             type = typeof(string);
  34.                         }
  35.                         Json.Append("\"" + pi[j].Name.ToString() + "\":" + StringFormat(v, type));
  36.                         if (j < pi.Length - 1)
  37.                         {
  38.                             Json.Append(",");
  39.                         }
  40.                     }
  41.                     Json.Append("}");
  42.                     if (i < list.Count - 1)
  43.                     {
  44.                         Json.Append(",");
  45.                     }
  46.                 }
  47.             }
  48.             Json.Append("]}");
  49.             return Json.ToString();
  50.         }
  51.         /// <summary>
  52.         /// 序列化集合对象
  53.         /// </summary>
  54.         public static string JsonSerializerByArrayData<T>(T[] tArray)
  55.         {
  56.             DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T[]));
  57.             MemoryStream ms = new MemoryStream();
  58.             ser.WriteObject(ms, tArray);
  59.             string jsonString = Encoding.UTF8.GetString(ms.ToArray());
  60.             ms.Close();
  61.             string p = @"\\/Date\((\d+)\+\d+\)\\/";
  62.             MatchEvaluator matchEvaluator = new MatchEvaluator(ConvertJsonDateToDateString);
  63.             Regex reg = new Regex(p);
  64.             jsonString = reg.Replace(jsonString, matchEvaluator);
  65.             return jsonString;
  66.         }
  67.         /// <summary>
  68.         /// 序列化单个对象
  69.         /// </summary>
  70.         public static string JsonSerializerBySingleData<T>(T t)
  71.         {
  72.             DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
  73.             MemoryStream ms = new MemoryStream();
  74.             ser.WriteObject(ms, t);
  75.             string jsonString = Encoding.UTF8.GetString(ms.ToArray());
  76.             ms.Close();
  77.             string p = @"\\/Date\((\d+)\+\d+\)\\/";
  78.             MatchEvaluator matchEvaluator = new MatchEvaluator(ConvertJsonDateToDateString);
  79.             Regex reg = new Regex(p);
  80.             jsonString = reg.Replace(jsonString, matchEvaluator);
  81.             return jsonString;
  82.         }
  83.         /// <summary> 
  84.         /// 反序列化单个对象
  85.         /// </summary> 
  86.         public static T JsonDeserializeBySingleData<T>(string jsonString)
  87.         {
  88.             //将"yyyy-MM-dd HH:mm:ss"格式的字符串转为"\/Date(1294499956278+0800)\/"格式  
  89.             string p = @"\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}";
  90.             MatchEvaluator matchEvaluator = new MatchEvaluator(ConvertDateStringToJsonDate);
  91.             Regex reg = new Regex(p);
  92.             jsonString = reg.Replace(jsonString, matchEvaluator);
  93.             DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
  94.             MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
  95.             T obj = (T)ser.ReadObject(ms);
  96.             return obj;
  97.         }
  98.         /// <summary> 
  99.         /// 反序列化集合对象
  100.         /// </summary> 
  101.         public static T[] JsonDeserializeByArrayData<T>(string jsonString)
  102.         {
  103.             //将"yyyy-MM-dd HH:mm:ss"格式的字符串转为"\/Date(1294499956278+0800)\/"格式  
  104.             string p = @"\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}";
  105.             MatchEvaluator matchEvaluator = new MatchEvaluator(ConvertDateStringToJsonDate);
  106.             Regex reg = new Regex(p);
  107.             jsonString = reg.Replace(jsonString, matchEvaluator);
  108.             DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T[]));
  109.             MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
  110.             T[] arrayObj = (T[])ser.ReadObject(ms);
  111.             return arrayObj;
  112.         }
  113.         /// <summary>
  114.         /// 将json数据反序列化为Dictionary
  115.         /// </summary>
  116.         /// <param name="jsonData">json数据</param>
  117.         /// <returns></returns>
  118.         public static Dictionary<stringobjectJsonToDictionary(string jsonData)
  119.         {
  120.             //实例化JavaScriptSerializer类的新实例
  121.             JavaScriptSerializer jss = new JavaScriptSerializer();
  122.             try
  123.             {
  124.                 //将指定的 JSON 字符串转换为 Dictionary<string, object> 类型的对象
  125.                 return jss.Deserialize<Dictionary<stringobject>>(jsonData);
  126.             }
  127.             catch (Exception ex)
  128.             {
  129.                 throw new Exception(ex.Message);
  130.             }
  131.         }
  132.         /// <summary> 
  133.         /// 将Json序列化的时间由/Date(1294499956278+0800)转为字符串 
  134.         /// </summary> 
  135.         private static string ConvertJsonDateToDateString(Match m)
  136.         {
  137.             string result = string.Empty;
  138.             DateTime dt = new DateTime(197011);
  139.             dt = dt.AddMilliseconds(long.Parse(m.Groups[1].Value));
  140.             dt = dt.ToLocalTime();
  141.             result = dt.ToString("yyyy-MM-dd HH:mm:ss");
  142.             return result;
  143.         }
  144.         /// <summary>  
  145.         /// 将时间字符串转为Json时间 
  146.         /// </summary> 
  147.         private static string ConvertDateStringToJsonDate(Match m)
  148.         {
  149.             string result = string.Empty;
  150.             DateTime dt = DateTime.Parse(m.Groups[0].Value);
  151.             dt = dt.ToUniversalTime();
  152.             TimeSpan ts = dt - DateTime.Parse("1970-01-01");
  153.             result = string.Format("\\/Date({0}+0800)\\/", ts.TotalMilliseconds);
  154.             return result;
  155.         }
  156.         /// <summary>
  157.         /// List转成json 
  158.         /// </summary>
  159.         /// <typeparam name="T"></typeparam>
  160.         /// <param name="list"></param>
  161.         /// <returns></returns>
  162.         public static string ListToJson<T>(IList<T> list)
  163.         {
  164.             object obj = list[0];
  165.             return ListToJson<T>(list, obj.GetType().Name);
  166.         }
  167.         /// <summary> 
  168.         /// 对象转换为Json字符串 
  169.         /// </summary> 
  170.         /// <param name="jsonObject">对象</param> 
  171.         /// <returns>Json字符串</returns> 
  172.         public static string ToJson(object jsonObject)
  173.         {
  174.             if (jsonObject == nullreturn "{}";
  175.             try
  176.             {
  177.                 StringBuilder jsonString = new StringBuilder();
  178.                 jsonString.Append("{");
  179.                 PropertyInfo[] propertyInfo = jsonObject.GetType().GetProperties();
  180.                 for (int i = 0; i < propertyInfo.Length; i++)
  181.                 {
  182.                     object objectValue = propertyInfo[i].GetGetMethod().Invoke(jsonObject, null);
  183.                     if (objectValue == null)
  184.                     {
  185.                         continue;
  186.                     }
  187.                     StringBuilder value = new StringBuilder();
  188.                     if (objectValue is DateTime || objectValue is Guid || objectValue is TimeSpan)
  189.                     {
  190.                         value.Append("\"" + objectValue.ToString() + "\"");
  191.                     }
  192.                     else if (objectValue is string)
  193.                     {
  194.                         value.Append("\"" + objectValue.ToString().Replace("\"""\\\"") + "\"");
  195.                     }
  196.                     else if (objectValue is IEnumerable)
  197.                     {
  198.                         value.Append(ToJson((IEnumerable)objectValue));
  199.                     }
  200.                     else
  201.                     {
  202.                         value.Append("\"" + objectValue.ToString() + "\"");
  203.                     }
  204.                     jsonString.Append("\"" + propertyInfo[i].Name + "\":" + value + ","); ;
  205.                 }
  206.                 return jsonString.ToString().TrimEnd(',') + "}";
  207.             }
  208.             catch (Exception ex)
  209.             {
  210.                 throw ex;
  211.             }
  212.         }
  213.         /// <summary> 
  214.         /// 对象集合转换Json 
  215.         /// </summary> 
  216.         /// <param name="array">集合对象</param> 
  217.         /// <returns>Json字符串</returns> 
  218.         public static string ToJson(IEnumerable array)
  219.         {
  220.             if (array == nullreturn "[]";
  221.             string jsonString = "[";
  222.             foreach (object item in array)
  223.             {
  224.                 jsonString += ToJson(item) + ",";
  225.             }
  226.             if (jsonString.Length > 1)
  227.             {
  228.                 jsonString = jsonString.TrimEnd(',');
  229.                 //jsonString.Remove(jsonString.Length - 1, jsonString.Length);
  230.             }
  231.             else
  232.             {
  233.                 jsonString = "[]";
  234.             }
  235.             return jsonString + "]";
  236.         }
  237.         /// <summary> 
  238.         /// 普通集合转换Json 
  239.         /// </summary> 
  240.         /// <param name="array">集合对象</param> 
  241.         /// <returns>Json字符串</returns> 
  242.         public static string ToArrayString(IEnumerable array)
  243.         {
  244.             string jsonString = "[";
  245.             foreach (object item in array)
  246.             {
  247.                 jsonString = ToJson(item.ToString()) + ",";
  248.             }
  249.             jsonString.Remove(jsonString.Length - 1, jsonString.Length);
  250.             return jsonString + "]";
  251.         }
  252.         /// <summary> 
  253.         /// Datatable转换为Json 
  254.         /// </summary> 
  255.         /// <param name="table">Datatable对象</param> 
  256.         /// <returns>Json字符串</returns> 
  257.         public static string ToJson(DataTable dt)
  258.         {
  259.             StringBuilder jsonString = new StringBuilder();
  260.             jsonString.Append("[");
  261.             DataRowCollection drc = dt.Rows;
  262.             for (int i = 0; i < drc.Count; i++)
  263.             {
  264.                 jsonString.Append("{");
  265.                 for (int j = 0; j < dt.Columns.Count; j++)
  266.                 {
  267.                     string strKey = dt.Columns[j].ColumnName;
  268.                     string strValue = drc[i][j].ToString();
  269.                     Type type = dt.Columns[j].DataType;
  270.                     jsonString.Append("\"" + strKey + "\":");
  271.                     strValue = StringFormat(strValue, type);
  272.                     if (j < dt.Columns.Count - 1)
  273.                     {
  274.                         jsonString.Append(strValue + ",");
  275.                     }
  276.                     else
  277.                     {
  278.                         jsonString.Append(strValue);
  279.                     }
  280.                 }
  281.                 jsonString.Append("},");
  282.             }
  283.             jsonString.Remove(jsonString.Length - 11);
  284.             jsonString.Append("]");
  285.             if (jsonString.Length == 1)
  286.             {
  287.                 return "[]";
  288.             }
  289.             return jsonString.ToString();
  290.         }
  291.         /// <summary>
  292.         /// DataTable转成Json 
  293.         /// </summary>
  294.         /// <param name="jsonName"></param>
  295.         /// <param name="dt"></param>
  296.         /// <returns></returns>
  297.         public static string ToJson(DataTable dt, string jsonName)
  298.         {
  299.             StringBuilder Json = new StringBuilder();
  300.             if (string.IsNullOrEmpty(jsonName))
  301.                 jsonName = dt.TableName;
  302.             Json.Append("{\"" + jsonName + "\":[");
  303.             if (dt.Rows.Count > 0)
  304.             {
  305.                 for (int i = 0; i < dt.Rows.Count; i++)
  306.                 {
  307.                     Json.Append("{");
  308.                     for (int j = 0; j < dt.Columns.Count; j++)
  309.                     {
  310.                         Type type = dt.Rows[i][j].GetType();
  311.                         Json.Append("\"" + dt.Columns[j].ColumnName.ToString() + "\":" + StringFormat(dt.Rows[i][j] is DBNull ? string.Empty : dt.Rows[i][j].ToString(), type));
  312.                         if (j < dt.Columns.Count - 1)
  313.                         {
  314.                             Json.Append(",");
  315.                         }
  316.                     }
  317.                     Json.Append("}");
  318.                     if (i < dt.Rows.Count - 1)
  319.                     {
  320.                         Json.Append(",");
  321.                     }
  322.                 }
  323.             }
  324.             Json.Append("]}");
  325.             return Json.ToString();
  326.         }
  327.         /// <summary> 
  328.         /// DataReader转换为Json 
  329.         /// </summary> 
  330.         /// <param name="dataReader">DataReader对象</param> 
  331.         /// <returns>Json字符串</returns> 
  332.         public static string ToJson(IDataReader dataReader)
  333.         {
  334.             try
  335.             {
  336.                 StringBuilder jsonString = new StringBuilder();
  337.                 jsonString.Append("[");
  338.                 while (dataReader.Read())
  339.                 {
  340.                     jsonString.Append("{");
  341.                     for (int i = 0; i < dataReader.FieldCount; i++)
  342.                     {
  343.                         Type type = dataReader.GetFieldType(i);
  344.                         string strKey = dataReader.GetName(i);
  345.                         string strValue = dataReader[i].ToString();
  346.                         jsonString.Append("\"" + strKey + "\":");
  347.                         strValue = StringFormat(strValue, type);
  348.                         if (i < dataReader.FieldCount - 1)
  349.                         {
  350.                             jsonString.Append(strValue + ",");
  351.                         }
  352.                         else
  353.                         {
  354.                             jsonString.Append(strValue);
  355.                         }
  356.                     }
  357.                     jsonString.Append("},");
  358.                 }
  359.                 if (!dataReader.IsClosed)
  360.                 {
  361.                     dataReader.Close();
  362.                 }
  363.                 jsonString.Remove(jsonString.Length - 11);
  364.                 jsonString.Append("]");
  365.                 if (jsonString.Length == 1)
  366.                 {
  367.                     return "[]";
  368.                 }
  369.                 return jsonString.ToString();
  370.             }
  371.             catch (Exception ex)
  372.             {
  373.                 throw ex;
  374.             }
  375.         }
  376.         /// <summary> 
  377.         /// DataSet转换为Json 
  378.         /// </summary> 
  379.         /// <param name="dataSet">DataSet对象</param> 
  380.         /// <returns>Json字符串</returns> 
  381.         public static string ToJson(DataSet dataSet)
  382.         {
  383.             string jsonString = "{";
  384.             foreach (DataTable table in dataSet.Tables)
  385.             {
  386.                 jsonString += "\"" + table.TableName + "\":" + ToJson(table) + ",";
  387.             }
  388.             jsonString = jsonString.TrimEnd(',');
  389.             return jsonString + "}";
  390.         }
  391.         /// <summary>
  392.         /// 过滤特殊字符
  393.         /// </summary>
  394.         /// <param name="s"></param>
  395.         /// <returns></returns>
  396.         public static string String2Json(String s)
  397.         {
  398.             StringBuilder sb = new StringBuilder();
  399.             for (int i = 0; i < s.Length; i++)
  400.             {
  401.                 char c = s.ToCharArray()[i];
  402.                 switch (c)
  403.                 {
  404.                     case '\"':
  405.                         sb.Append("\\\""); break;
  406.                     case '\\':
  407.                         sb.Append("\\\\"); break;
  408.                     case '/':
  409.                         sb.Append("\\/"); break;
  410.                     case '\b':
  411.                         sb.Append("\\b"); break;
  412.                     case '\f':
  413.                         sb.Append("\\f"); break;
  414.                     case '\n':
  415.                         sb.Append("\\n"); break;
  416.                     case '\r':
  417.                         sb.Append("\\r"); break;
  418.                     case '\t':
  419.                         sb.Append("\\t"); break;
  420.                     case '\v':
  421.                         sb.Append("\\v"); break;
  422.                     case '\0':
  423.                         sb.Append("\\0"); break;
  424.                     default:
  425.                         sb.Append(c); break;
  426.                 }
  427.             }
  428.             return sb.ToString();
  429.         }
  430.         /// <summary>
  431.         /// 格式化字符型、日期型、布尔型
  432.         /// </summary>
  433.         /// <param name="str"></param>
  434.         /// <param name="type"></param>
  435.         /// <returns></returns>
  436.         private static string StringFormat(string str, Type type)
  437.         {
  438.             if (type != typeof(string) && string.IsNullOrEmpty(str))
  439.             {
  440.                 str = "\"" + str + "\"";
  441.             }
  442.             else if (type == typeof(string))
  443.             {
  444.                 str = String2Json(str);
  445.                 str = "\"" + str + "\"";
  446.             }
  447.             else if (type == typeof(DateTime))
  448.             {
  449.                 str = "\"" + str + "\"";
  450.             }
  451.             else if (type == typeof(bool))
  452.             {
  453.                 str = str.ToLower();
  454.             }
  455.             else if (type == typeof(byte[]))
  456.             {
  457.                 str = "\"" + str + "\"";
  458.             }
  459.             else if (type == typeof(Guid))
  460.             {
  461.                 str = "\"" + str + "\"";
  462.             }
  463.             return str;
  464.         }
  465.         /// <summary>
  466.         /// 将json转换为DataTable
  467.         /// </summary>
  468.         /// <param name="strJson">得到的json</param>
  469.         /// <returns></returns>
  470.         public static DataTable JsonToDataTable(string strJson)
  471.         {
  472.             //转换json格式
  473.             strJson = strJson.Replace(",\"""*\"").Replace("\":""\"#").ToString();
  474.             //取出表名   
  475.             var rg = new Regex(@"(?<={)[^:]+(?=:\[)", RegexOptions.IgnoreCase);
  476.             string strName = rg.Match(strJson).Value;
  477.             DataTable tb = null;
  478.             //去除表名   
  479.             strJson = strJson.Substring(strJson.IndexOf("[") + 1);
  480.             strJson = strJson.Substring(0, strJson.IndexOf("]"));
  481.             //获取数据   
  482.             rg = new Regex(@"(?<={)[^}]+(?=})");
  483.             MatchCollection mc = rg.Matches(strJson);
  484.             for (int i = 0; i < mc.Count; i++)
  485.             {
  486.                 string strRow = mc[i].Value;
  487.                 string[] strRows = strRow.Split('*');
  488.                 //创建表   
  489.                 if (tb == null)
  490.                 {
  491.                     tb = new DataTable();
  492.                     tb.TableName = strName;
  493.                     foreach (string str in strRows)
  494.                     {
  495.                         var dc = new DataColumn();
  496.                         string[] strCell = str.Split('#');
  497.                         if (strCell[0].Substring(01) == "\"")
  498.                         {
  499.                             int a = strCell[0].Length;
  500.                             dc.ColumnName = strCell[0].Substring(1, a - 2);
  501.                         }
  502.                         else
  503.                         {
  504.                             dc.ColumnName = strCell[0];
  505.                         }
  506.                         tb.Columns.Add(dc);
  507.                     }
  508.                     tb.AcceptChanges();
  509.                 }
  510.                 //增加内容   
  511.                 DataRow dr = tb.NewRow();
  512.                 for (int r = 0; r < strRows.Length; r++)
  513.                 {
  514.                     dr[r] = strRows[r].Split('#')[1].Trim().Replace(","",").Replace(":"":").Replace("\"""");
  515.                 }
  516.                 tb.Rows.Add(dr);
  517.                 tb.AcceptChanges();
  518.             }
  519.             return tb;
  520.         }
  521.         /// <summary>
  522.         /// 将JSON解析成DataSet只限标准的JSON数据
  523.         /// 例如:Json={t1:[{name:'数据name',type:'数据type'}]} 
  524.         /// 或 Json={t1:[{name:'数据name',type:'数据type'}],t2:[{id:'数据id',gx:'数据gx',val:'数据val'}]}
  525.         /// </summary>
  526.         /// <param name="Json">Json字符串</param>
  527.         /// <returns>DataSet</returns>
  528.         public static DataSet JsonToDataSet(string Json)
  529.         {
  530.             try
  531.             {
  532.                 DataSet ds = new DataSet();
  533.                 JavaScriptSerializer JSS = new JavaScriptSerializer();
  534.                 object obj = JSS.DeserializeObject(Json);
  535.                 Dictionary<stringobject> datajson = (Dictionary<stringobject>)obj;
  536.                 foreach (var item in datajson)
  537.                 {
  538.                     DataTable dt = new DataTable(item.Key);
  539.                     object[] rows = (object[])item.Value;
  540.                     foreach (var row in rows)
  541.                     {
  542.                         Dictionary<stringobject> val = (Dictionary<stringobject>)row;
  543.                         DataRow dr = dt.NewRow();
  544.                         foreach (KeyValuePair<stringobject> sss in val)
  545.                         {
  546.                             if (!dt.Columns.Contains(sss.Key))
  547.                             {
  548.                                 dt.Columns.Add(sss.Key.ToString());
  549.                                 dr[sss.Key] = sss.Value;
  550.                             }
  551.                             else
  552.                                 dr[sss.Key] = sss.Value;
  553.                         }
  554.                         dt.Rows.Add(dr);
  555.                     }
  556.                     ds.Tables.Add(dt);
  557.                 }
  558.                 return ds;
  559.             }
  560.             catch
  561.             {
  562.                 return null;
  563.             }
  564.         }
  565.     }


评价

拓展js通用方法对应c操作

有很多时候,js不能像c#一样有那样多的方法操作,但是我们可以自己写一些方法,让他拥有:比如最常见的一些:注意:js里的...

.net mvc 登录后跳回原的页面

把当前连接传递到登录界面,然后登录后根据那个连接跳转回来就好跳转前可以使用Request.Url获取当前页面的地址:&lt;ahref=...

Net Core使用依赖注入装载EF的上下文对象

妹子情人节快乐~.net core中用了不少的依赖注入,官方文档中也推荐使用。这样使用依赖注入来管理ef对象,还是比较科学,比如...

Web前段框架技术之全选,全不选,反选并显示出

我们用到&lt;input&gt;标签,再每一个&lt;input&gt;标签取一个相同的name值。如下图:开始我们的骚操作,用Web前段框架技术...

从博客文章的路由看一点处理查询的方法

例如我们来看看一篇文章的路由www.tnblog.net/aojiancc2/article/details/2670这里的aojiancc2是用户名,后面的2670是id其...

ASP.NET MVC Controller接收ajax post方式发送过json对象或数组数据

1、将json数组或者json对象用JSON.stringify()方法序列化成字符串,再将字符串提交到后台。varstuarr=newArray();//创建一...

搞一个接口玩玩

可能自己需要加一些其他数据,然后又懒得写后台配置服务部署,可以自己去弄个网络上的接口拿来加载就可以了,返回的都是jso...

identity server4登录成功后,跳转到原的页面

我们用identity server4现在访问权限一般都是在某个控制器加上Authorize特性,这样就会访问他的时候跳转到授权中心。这种方...

前端、Cordova安卓、iOS开发,全自学 一个星期多时间累死我了,撑过

前言自学前端之路:不知不觉出来工作已经快一个月了,给你们分享一下状况正文最近公司用的项目是ionic框架开发不得不自学哇...

layer设置area后按钮掉下

如果页面一加载就弹出layer,layer设置area后按钮就会掉下来,感觉也这算layer的一个bug可以把高度设置成auto按钮就不会掉下...

东途网:新手如何运营抖音?最全运营技巧、注意事项啦!

东途网:www.dtwl.top新手如何运营抖音?最全运营技巧、注意事项来啦!抖音是目前最火爆的短视频,越来越多的人都离不开短视...

jstree事件中拿绑定的原始数据

比如要拿到绑定的id其实里边有个original属性就是绑定上来的原始对象,这样就可以随便的拿到了,这个树形组件封装得还是很...

英特尔酷睿和AMD锐龙应该怎么选?我告诉你!

我还是很喜欢你,像风走了八百里,不知疲倦,不问归期!关于电脑的硬件选择,似乎很多人都在纠结。主板纠结,内存纠结,固...

带货达人布局短视频带货,下一个风口到

2020年开始就陆续有阿里和腾讯双马等等互联网两大龙头率领下纷纷坚持,这说明什么?  而根据据最新公开资料显示,截至2020...

treeview右键菜单避免在空白处弹出

如果直接这样绑定在树形菜单中,在空白处也会弹出来的思路应该是不直接绑定到控件,手动弹出菜单,弹出规则可以自定义,这...
不需要签名
排名
4
文章
473
粉丝
3
评论
2
Oracle中MERGE INTO,for,start with,decode用法
剑轩 : 多来一点点解释就更好了
ICP备案 :渝ICP备18016597号-1
网站信息:2018-2025TNBLOG.NET
技术交流:群号656732739
联系我们:contact@tnblog.net
公网安备:50010702506256
欢迎加群交流技术