ssr 订阅
SSR是各种集换式卡牌游戏中,卡牌稀有度级别分类的一种。稀有度级别一般为 UR>SSR>SR>R> N(部分集换式卡牌游戏设定中最高级别为SSR)。不限于某个或者某几个游戏特用名词,是一种被集换式卡牌游戏广泛使用的稀有度等级分类。SSR卡牌一般获取几率为1%左右。 展开全文
SSR是各种集换式卡牌游戏中,卡牌稀有度级别分类的一种。稀有度级别一般为 UR>SSR>SR>R> N(部分集换式卡牌游戏设定中最高级别为SSR)。不限于某个或者某几个游戏特用名词,是一种被集换式卡牌游戏广泛使用的稀有度等级分类。SSR卡牌一般获取几率为1%左右。
信息
外文名
SSR
出    处
各类卡牌类手游
中文名
金色传说/特超稀有
获取概率
1%左右
source insight功能
SSR全称为superior super rare,特级超稀有。一般为集换式卡牌游戏最高稀有等级。除此之外的其他稀有级:UR:Ultra Rare极度稀有例如第五人格绿纹大触、蒸汽朋克等(某些集换式卡牌游戏里等同于SSR,甚至高于SSR)SR:Super Rare超稀有(一般低于)R:Rare稀有(一般作为协战点/友情/助战点能抽到的稀有度上限)N:Normal普通(最常见最容易到手的稀有度级别
收起全文
精华内容
参与话题
问答
  • ssr-win.zip

    2020-03-05 18:35:43
    首先下载好ssr-win.7z,下载链接:点我 2、将下载好的压缩包解压到桌面的某个文件夹里 3、打开下图圈中的exe文件 4、随后在系统的任务栏里找到小飞机 5、...
  • SSR

    千次阅读 2019-08-09 10:54:08
    什么是服务器端渲染 (SSR) 服务器将组件和获取到的数据解析生成html字符串,发送给客户端。过程同之前的php、java等的全栈开发,使用模板引擎,获取数据后解析为html字符串后,发到客户端展现。 服务器渲染的 Vue....

    前后端分离后单页面应用盛行,出现了服务端渲染的说法,其能更好的SEO

    什么是服务器端渲染 (SSR)

    • 服务器将组件和获取到的数据解析生成html字符串,发送给客户端。过程同之前的php、java等的全栈开发,使用模板引擎,获取数据后解析为html字符串后,发到客户端展现。
    • 服务器渲染的 Vue.js 应用程序,可以同时在服务器客户端上运行。

    为什么使用服务器端渲染 (SSR)

    • 更好的 SEO
      Google 和 Bing 可以很好对同步 JavaScript 应用程序进行索引。
    • 更快的内容到达时间 (time-to-content)
      无需等待所有的 JavaScript 都完成下载并执行。

    服务器端渲染 vs 预渲染 (SSR vs Prerendering)

    少数营销页面(例如 /, /about, /contact 等)的 SEO,预渲染。

    Nuxt.js通用应用框架

    一个基于 Vue.js 的服务端渲染应用框架

    流程图

    nuxt流程图

    双模式

    编译后同时生成客户端和服务端代码
    在这里插入图片描述

    • url访问地址,服务端渲染后发给客户端
      服务端渲染************************************************************************************************************
    • 页面中nuxt-link标签跳转,客户端渲染。history模式,无刷新跳转(同单页应用路由跳转)
      客户端渲染
    函数 服务端 路由更新 触发时间 其它
    nuxtServerInit 触发 不触发 store/index.js中设置
    asyncData 触发 触发 组件加载之前被调用 融合data返回
    fetch 触发 触发 渲染页面前被调用 填充(store)数据

    注意事项

    • 需要服务端渲染的数据使用asyncData获取
    • vue生命周期中获取的数据会保持客户端渲染(如下mounted中获取)
      在这里插入图片描述
    展开全文
  • ssr、订阅内容解析

    万次阅读 2019-07-19 12:14:53
    // ssr地址解析 var ssrObj = new SSR.Server("ssr://xxx", ""); ssrObj.remarks = "ssr name"; var ssrUrl = ssrObj.GetSSRLinkForServer(); // ssr地址与订阅内容转换 var ssrUrls = new[] { "ssr:\\xxx","ssr:\\...

     

    // ssr地址解析
    var ssrObj = new SSR.Server("ssr://xxx", "");
    ssrObj.remarks = "ssr name";
    var ssrUrl = ssrObj.GetSSRLinkForServer();
    
    // ssr地址与订阅内容转换
    var ssrUrls = new[] { "ssr:\\xxx","ssr:\\xxx"};
    var subscribeContent = SSR.Subscriber.ToSubscribeStr(ssrUrls);
    var ssrUrls2 = SSR.Subscriber.FromSubscribeStr(subscribeContent);

     

    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Linq;
    using System.Net;
    using System.Net.Sockets;
    using System.Security.Cryptography;
    using System.Text;
    using System.Text.RegularExpressions;
    
    namespace WebApplication1
    {
        public class SSR
        {
            /// <summary>
            /// SS、SSR地址编解码
            /// </summary>
            [Serializable]
            public class Server
            {
                public string id;
                public string server;
                public int server_port;
                public int server_udp_port;
                public string password;
                public string method;
                public string protocol;
                public string protocolparam;
                public string obfs;
                public string obfsparam;
                public string remarks_base64;
                public string group;
                public bool enable;
                public bool udp_over_tcp;
                public int latency;
                public static int LATENCY_ERROR = -2;
                public static int LATENCY_PENDING = -1;
                public static int LATENCY_TESTING = 0;
                private object protocoldata;
                private object obfsdata;
                private static Server forwardServer = new Server();
                public string remarks
                {
                    get
                    {
                        if (this.remarks_base64.Length == 0)
                        {
                            return string.Empty;
                        }
                        string result;
                        try
                        {
                            result = Base64.DecodeUrlSafeBase64(this.remarks_base64);
                        }
                        catch (FormatException)
                        {
                            string text = this.remarks_base64;
                            this.remarks = this.remarks_base64;
                            result = text;
                        }
                        return result;
                    }
                    set
                    {
                        this.remarks_base64 = Base64.EncodeUrlSafeBase64(value, true);
                    }
                }
                public void CopyServer(Server Server)
                {
                    this.protocoldata = Server.protocoldata;
                    this.obfsdata = Server.obfsdata;
                    this.enable = Server.enable;
                }
                public void CopyServerInfo(Server Server)
                {
                    this.remarks = Server.remarks;
                    this.group = Server.group;
                }
                public static Server GetForwardServerRef()
                {
                    return Server.forwardServer;
                }
                public string FriendlyName()
                {
                    if (string.IsNullOrEmpty(this.server))
                    {
                        return "New server";
                    }
                    if (string.IsNullOrEmpty(this.remarks_base64))
                    {
                        if (this.server.IndexOf(':') >= 0)
                        {
                            return string.Concat(new object[]
                            {
                            "[",
                            this.server,
                            "]:",
                            this.server_port
                            });
                        }
                        return this.server + ":" + this.server_port;
                    }
                    else
                    {
                        if (this.server.IndexOf(':') >= 0)
                        {
                            return string.Concat(new object[]
                            {
                            this.remarks,
                            " ([",
                            this.server,
                            "]:",
                            this.server_port,
                            ")"
                            });
                        }
                        return string.Concat(new object[]
                        {
                        this.remarks,
                        " (",
                        this.server,
                        ":",
                        this.server_port,
                        ")"
                        });
                    }
                }
                public string HiddenName(bool hide = true)
                {
                    if (string.IsNullOrEmpty(this.server))
                    {
                        return "New server";
                    }
                    string text = this.server;
                    if (hide)
                    {
                        text = ServerName.HideServerAddr(this.server);
                    }
                    if (string.IsNullOrEmpty(this.remarks_base64))
                    {
                        if (this.server.IndexOf(':') >= 0)
                        {
                            return string.Concat(new object[]
                            {
                            "[",
                            text,
                            "]:",
                            this.server_port
                            });
                        }
                        return text + ":" + this.server_port;
                    }
                    else
                    {
                        if (this.server.IndexOf(':') >= 0)
                        {
                            return string.Concat(new object[]
                            {
                            this.remarks,
                            " ([",
                            text,
                            "]:",
                            this.server_port,
                            ")"
                            });
                        }
                        return string.Concat(new object[]
                        {
                        this.remarks,
                        " (",
                        text,
                        ":",
                        this.server_port,
                        ")"
                        });
                    }
                }
                public Server Clone()
                {
                    return new Server
                    {
                        server = this.server,
                        server_port = this.server_port,
                        password = this.password,
                        method = this.method,
                        protocol = this.protocol,
                        obfs = this.obfs,
                        obfsparam = this.obfsparam ?? "",
                        remarks_base64 = this.remarks_base64,
                        group = this.group,
                        enable = this.enable,
                        udp_over_tcp = this.udp_over_tcp,
                        id = this.id,
                        protocoldata = this.protocoldata,
                        obfsdata = this.obfsdata
                    };
                }
                public Server()
                {
                    this.server = "server host";
                    this.server_port = 8388;
                    this.method = "aes-256-cfb";
                    this.protocol = "origin";
                    this.protocolparam = "";
                    this.obfs = "plain";
                    this.obfsparam = "";
                    this.password = "0";
                    this.remarks_base64 = "";
                    this.group = "FreeSSR-public";
                    this.udp_over_tcp = false;
                    this.enable = true;
                    this.latency = Server.LATENCY_PENDING;
                    byte[] array = new byte[16];
                    Utils.RandBytes(array, array.Length);
                    this.id = BitConverter.ToString(array).Replace("-", "");
                }
                public Server(string ssURL, string force_group) : this()
                {
                    if (ssURL.StartsWith("ss://", StringComparison.OrdinalIgnoreCase))
                    {
                        this.ServerFromSS(ssURL, force_group);
                        return;
                    }
                    if (ssURL.StartsWith("ssr://", StringComparison.OrdinalIgnoreCase))
                    {
                        this.ServerFromSSR(ssURL, force_group);
                        return;
                    }
                    throw new FormatException();
                }
                public bool isMatchServer(Server server)
                {
                    return this.server == server.server && this.server_port == server.server_port && this.server_udp_port == server.server_udp_port && this.method == server.method && this.protocol == server.protocol && this.protocolparam == server.protocolparam && this.obfs == server.obfs && this.obfsparam == server.obfsparam && this.password == server.password && this.udp_over_tcp == server.udp_over_tcp;
                }
                private Dictionary<string, string> ParseParam(string param_str)
                {
                    Dictionary<string, string> dictionary = new Dictionary<string, string>();
                    string[] array = param_str.Split(new char[]
                    {
                    '&'
                    });
                    string[] array2 = array;
                    for (int i = 0; i < array2.Length; i++)
                    {
                        string text = array2[i];
                        if (text.IndexOf('=') > 0)
                        {
                            int num = text.IndexOf('=');
                            string key = text.Substring(0, num);
                            string value = text.Substring(num + 1);
                            dictionary[key] = value;
                        }
                    }
                    return dictionary;
                }
                public void ServerFromSSR(string ssrURL, string force_group)
                {
                    Match match = Regex.Match(ssrURL, "ssr://([A-Za-z0-9_-]+)", RegexOptions.IgnoreCase);
                    if (!match.Success)
                    {
                        throw new FormatException();
                    }
                    string text = Base64.DecodeUrlSafeBase64(match.Groups[1].Value);
                    Dictionary<string, string> dictionary = new Dictionary<string, string>();
                    int num = text.IndexOf("?");
                    if (num > 0)
                    {
                        dictionary = this.ParseParam(text.Substring(num + 1));
                        text = text.Substring(0, num);
                    }
                    if (text.IndexOf("/") >= 0)
                    {
                        text = text.Substring(0, text.LastIndexOf("/"));
                    }
                    Regex regex = new Regex("^(.+):([^:]+):([^:]*):([^:]+):([^:]*):([^:]+)");
                    Match match2 = regex.Match(text);
                    if (match2 == null || !match2.Success)
                    {
                        throw new FormatException();
                    }
                    this.server = match2.Groups[1].Value;
                    this.server_port = int.Parse(match2.Groups[2].Value);
                    this.protocol = ((match2.Groups[3].Value.Length == 0) ? "origin" : match2.Groups[3].Value);
                    this.protocol = this.protocol.Replace("_compatible", "");
                    this.method = match2.Groups[4].Value;
                    this.obfs = ((match2.Groups[5].Value.Length == 0) ? "plain" : match2.Groups[5].Value);
                    this.obfs = this.obfs.Replace("_compatible", "");
                    this.password = Base64.DecodeStandardSSRUrlSafeBase64(match2.Groups[6].Value);
                    if (dictionary.ContainsKey("protoparam"))
                    {
                        this.protocolparam = Base64.DecodeStandardSSRUrlSafeBase64(dictionary["protoparam"]);
                    }
                    if (dictionary.ContainsKey("obfsparam"))
                    {
                        this.obfsparam = Base64.DecodeStandardSSRUrlSafeBase64(dictionary["obfsparam"]);
                    }
                    if (dictionary.ContainsKey("remarks"))
                    {
                        this.remarks = Base64.DecodeStandardSSRUrlSafeBase64(dictionary["remarks"]);
                    }
                    if (dictionary.ContainsKey("group"))
                    {
                        this.group = Base64.DecodeStandardSSRUrlSafeBase64(dictionary["group"]);
                    }
                    else
                    {
                        this.group = "";
                    }
                    if (dictionary.ContainsKey("uot"))
                    {
                        this.udp_over_tcp = (int.Parse(dictionary["uot"]) > 0);
                    }
                    if (dictionary.ContainsKey("udpport"))
                    {
                        this.server_udp_port = int.Parse(dictionary["udpport"]);
                    }
                    if (!string.IsNullOrEmpty(force_group))
                    {
                        this.group = force_group;
                    }
                }
                public void ServerFromSS(string ssURL, string force_group)
                {
                    Regex regex = new Regex("^(?i)ss://([A-Za-z0-9+-/=_]+)(#(.+))?", RegexOptions.IgnoreCase);
                    Regex regex2 = new Regex("^((?<method>.+):(?<password>.*)@(?<hostname>.+?):(?<port>\\d+?))$", RegexOptions.IgnoreCase);
                    Match match = regex.Match(ssURL);
                    if (!match.Success)
                    {
                        throw new FormatException();
                    }
                    string value = match.Groups[1].Value;
                    match = regex2.Match(Encoding.UTF8.GetString(Convert.FromBase64String(value.PadRight(value.Length + (4 - value.Length % 4) % 4, '='))));
                    this.protocol = "origin";
                    this.method = match.Groups["method"].Value;
                    this.password = match.Groups["password"].Value;
                    this.server = match.Groups["hostname"].Value;
                    this.server_port = int.Parse(match.Groups["port"].Value);
                    if (!string.IsNullOrEmpty(force_group))
                    {
                        this.group = force_group;
                        return;
                    }
                    this.group = "";
                }
                public string GetSSLinkForServer()
                {
                    string s = string.Concat(new object[]
                    {
                    this.method,
                    ":",
                    this.password,
                    "@",
                    this.server,
                    ":",
                    this.server_port
                    });
                    string str = Convert.ToBase64String(Encoding.UTF8.GetBytes(s)).Replace("=", "");
                    return "ss://" + str;
                }
                public string GetSSRLinkForServer()
                {
                    string str = string.Concat(new object[]
                    {
                    this.server,
                    ":",
                    this.server_port,
                    ":",
                    this.protocol,
                    ":",
                    this.method,
                    ":",
                    this.obfs,
                    ":",
                    Base64.EncodeUrlSafeBase64(this.password, true)
                    });
                    string text = "obfsparam=" + Base64.EncodeUrlSafeBase64(this.obfsparam ?? "", true);
                    if (!string.IsNullOrEmpty(this.protocolparam))
                    {
                        text = text + "&protoparam=" + Base64.EncodeUrlSafeBase64(this.protocolparam, true);
                    }
                    if (!string.IsNullOrEmpty(this.remarks))
                    {
                        text = text + "&remarks=" + Base64.EncodeUrlSafeBase64(this.remarks, true);
                    }
                    if (!string.IsNullOrEmpty(this.group))
                    {
                        text = text + "&group=" + Base64.EncodeUrlSafeBase64(this.group, true);
                    }
                    if (this.udp_over_tcp)
                    {
                        text += "&uot=1";
                    }
                    if (this.server_udp_port > 0)
                    {
                        text = text + "&udpport=" + this.server_udp_port.ToString();
                    }
                    string str2 = Base64.EncodeUrlSafeBase64(str + "/?" + text, true);
                    return "ssr://" + str2;
                }
                public bool isEnable()
                {
                    return this.enable;
                }
                public void setEnable(bool enable)
                {
                    this.enable = enable;
                }
                public object getObfsData()
                {
                    return this.obfsdata;
                }
                public void setObfsData(object data)
                {
                    this.obfsdata = data;
                }
                public object getProtocolData()
                {
                    return this.protocoldata;
                }
                public void setProtocolData(object data)
                {
                    this.protocoldata = data;
                }
                public void tcpingLatency()
                {
                    List<double> list = new List<double>();
                    TcpClient tcpClient = new TcpClient();
                    Stopwatch stopwatch = new Stopwatch();
                    stopwatch.Start();
                    try
                    {
                        Dns.GetHostAddresses(this.server);
                    }
                    catch (Exception)
                    {
                        this.latency = Server.LATENCY_ERROR;
                        return;
                    }
                    IAsyncResult asyncResult = tcpClient.BeginConnect(this.server, this.server_port, null, null);
                    if (asyncResult.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(2.0)))
                    {
                        stopwatch.Stop();
                        list.Add(stopwatch.Elapsed.TotalMilliseconds);
                    }
                    else
                    {
                        stopwatch.Stop();
                    }
                    try
                    {
                        tcpClient.Close();
                    }
                    catch (Exception)
                    {
                    }
                    if (list.Count != 0)
                    {
                        this.latency = (int)list.Average();
                        return;
                    }
                    this.latency = Server.LATENCY_ERROR;
                }
            }
    
            /// <summary>
            /// SS、SSR订阅内容生成
            /// </summary>
            public static class Subscriber
            {
                /// <summary>
                /// 将多个ssr地址转换为订阅内容
                /// </summary>
                /// <param name="ssrs">ssr地址列表</param>
                /// <returns></returns>
                public static string ToSubscribeStr(IEnumerable<string> ssrs)
                {
                    // 多个ssr地址用换行符分割,最后用base64编码
                    var str = string.Join("\r\n", ssrs);
                    var base64 = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(str));
                    return base64;
                }
    
                /// <summary>
                /// 从订阅内容中获取ssr地址列表
                /// </summary>
                /// <param name="subscribeContent">ssr订阅内容</param>
                /// <returns>ssr地址列表</returns>
                public static List<string> FromSubscribeStr(string subscribeContent)
                {
                    var str = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(subscribeContent));
                    var ssrs = str.Split("\r\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)
                        .ToList()
                        .FindAll(m => m.StartsWith("ss", StringComparison.InvariantCultureIgnoreCase));
                    return ssrs;
                }
            }
    
            private static class Base64
            {
                public static string DecodeBase64(string val)
                {
                    return Encoding.UTF8.GetString(Base64.DecodeBase64ToBytes(val));
                }
                public static byte[] DecodeBase64ToBytes(string val)
                {
                    string s = val.PadRight(val.Length + (4 - val.Length % 4) % 4, '=');
                    return Convert.FromBase64String(s);
                }
                public static string EncodeUrlSafeBase64(byte[] val, bool trim)
                {
                    if (trim)
                    {
                        return Convert.ToBase64String(val).Replace('+', '-').Replace('/', '_').TrimEnd(new char[]
                        {
                        '='
                        });
                    }
                    return Convert.ToBase64String(val).Replace('+', '-').Replace('/', '_');
                }
                public static byte[] DecodeUrlSafeBase64ToBytes(string val)
                {
                    string s = val.Replace('-', '+').Replace('_', '/').PadRight(val.Length + (4 - val.Length % 4) % 4, '=');
                    return Convert.FromBase64String(s);
                }
                public static string EncodeUrlSafeBase64(string val, bool trim = true)
                {
                    return Base64.EncodeUrlSafeBase64(Encoding.UTF8.GetBytes(val), trim);
                }
                public static string DecodeUrlSafeBase64(string val)
                {
                    return Encoding.UTF8.GetString(Base64.DecodeUrlSafeBase64ToBytes(val));
                }
                public static string DecodeStandardSSRUrlSafeBase64(string val)
                {
                    return Encoding.UTF8.GetString(Base64.DecodeUrlSafeBase64ToBytes(val));
                }
            }
    
            private static class ServerName
            {
                public static string HideServerAddr(string addr)
                {
                    string result = addr;
                    IPAddress iPAddress;
                    bool flag = IPAddress.TryParse(addr, out iPAddress);
                    if (flag)
                    {
                        char separator;
                        if (AddressFamily.InterNetwork == iPAddress.AddressFamily)
                        {
                            separator = '.';
                        }
                        else
                        {
                            separator = ':';
                        }
                        result = ServerName.HideAddr(addr, separator);
                    }
                    else
                    {
                        int num = addr.IndexOf('.', 1);
                        if (num > 0)
                        {
                            result = "*" + addr.Substring(num);
                        }
                    }
                    return result;
                }
                private static string HideAddr(string addr, char separator)
                {
                    string text = "";
                    string[] array = addr.Split(new char[]
                    {
                    separator
                    });
                    string text2 = array[0];
                    string text3 = array[array.Length - 1];
                    if (0 < text2.Length)
                    {
                        text = text2 + separator.ToString();
                    }
                    text += "**";
                    if (0 < text3.Length)
                    {
                        text = text + separator.ToString() + text3;
                    }
                    return text;
                }
            }
    
            private static class Utils
            {
                public static void RandBytes(byte[] buf, int length)
                {
                    byte[] array = new byte[length];
                    RNGCryptoServiceProvider rNGCryptoServiceProvider = new RNGCryptoServiceProvider();
                    rNGCryptoServiceProvider.GetBytes(array);
                    array.CopyTo(buf, 0);
                }
            }
        }
    }
    

     

    展开全文
  • 什么是SSR

    千次阅读 2020-01-18 14:32:40
    SSR是 Server-Side Rendering(服务器端渲染)的缩写,简单的理解就是将平时写的组件,页面通过服务器生成html字符串,再发送到浏览器,最后将静态标记,混合为客户端上交互的应用程序 ...

    SSR是 Server-Side Rendering(服务器端渲染)的缩写,简单的理解就是将平时写的组件,页面通过服务器生成html字符串,再发送到浏览器,最后将静态标记,混合为客户端上交互的应用程序

    接下来我们使用node简单的写个服务端渲染的例子:
    首先创建一个项目文件夹:
    1,初始化项目:yarn init -y
    2,下载对应的依赖包:
    yarn add -D koa koa-router koa-ejs
    3,在项目文件夹中创建app.js和一个template文件夹

    在这里插入图片描述
    4,app.js的代码

    const Koa = require('koa');
    const Router = require('koa-router');
    const path = require('path');
    const ejs = require('koa-ejs');
    
    const app = new Koa()
    const router = new Router()
    
    ejs(app, {
        root: path.join(__dirname, 'template'),
        layout: false,
        viewExt: 'ejs',
        cache: false,
        debug: false
    });
    
    router.get('/', async ctx => {
        await ctx.render('index', {
            title: 'test',
            arr: [
                {name: '小红', age: 12},
                {name: '小明', age: 23}
            ]
        })
    })
    
    app.use(router.routes())
    
    app.listen(3000)
    

    然后在template中创建index.ejs,index.ejs中的代码为:

    <!DOCTYPE html>
    <html>
    	<head>
    		<meta charset="utf-8">
    		<title><%= title %></title>
    	</head>
    	<body>
            <div>
                <%= title %>
            </div>
            <ul>
                <% arr.forEach(item => { %>
                    <li>
                        <span><%= item.name %></span> 
                        <span><%= item.age %></span>
                    </li>
                <%}) %>
            </ul>
            
    	</body>
    </html>
    
    

    接下来我们使用node app.js运行项目,在本地浏览器访问:http://localhost:3000/,就会看到如下页面
    在这里插入图片描述
    这个页面就是我们通过服务器渲染的页面
    通过服务器渲染的页面的优点和缺点可以看下面这个网址:
    https://www.jianshu.com/p/fcb98533bc18

    展开全文
  • 这个是ssr脚本的备用下载地址。该脚本亲测2020-3-13可用,如博客中正式使用地址无效后,可下载该脚本进行使用。但后续可能不会更新,见谅。这下载积分会自动增加,这样就很尴尬。。。
  • SSR(服务端渲染)

    千次阅读 2018-10-21 13:10:50
    前端面试题之SSR 客户端渲染: 在服务端放了一个html 页面,里面有 客户端发起请求,服务端把页面(响应的是字符串)发送过去,客户端从上到下依次解析,如果在解析的过程中,发现ajax 请求,再次像服务器发送新的...

    客户端渲染:

    在服务端放了一个html 页面,里面有

    客户端发起请求,服务端把页面(响应的是字符串)发送过去,客户端从上到下依次解析,如果在解析的过程中,发现ajax

    请求,再次像服务器发送新的请求,客户端拿到ajax 响应结果,模板引擎渲染。

    过程至少和服务端发起两次请求

    SSR:服务端渲染:

    sever 端页面+数据,服务端过程:1.读取index.html 2.模版进行渲染,在发送给客户端之前,在服务端已经把index.html 渲染处理了。var 渲染结果 = tempeter.render(模板字符串,{解析替换对象}) response.end(渲染结果),服务端响应的就是最总的结果

    服务端只请求一次

    多数网站既有服务端渲染又有客户端渲染

    服务端渲染和客户端渲染的区别

    • 客户端渲染不利于 SEO 搜索引擎优化
    • 服务端渲染是可以被爬虫抓取到的,客户端异步渲染是很难被爬虫抓取到的
    • 所以你会发现真正的网站既不是纯异步也不是纯服务端渲染出来的
    • 而是两者结合来做的
    • 例如京东的商品列表就采用的是服务端渲染,目的了为了 SEO 搜索引擎优化
    • 而它的商品评论列表为了用户体验,而且也不需要 SEO 优化,所以采用是客户端渲染

    原文:https://blog.csdn.net/wuhuimin521/article/details/79929834

    展开全文
  • 8.4.1 搭建自己的SSR

    2020-11-20 15:42:19
    SSR是未来前端页面必不可少的一个组成成分,掌握了Vue SSR基本上其他框架都非常类似。 3-4-1 搭建自己的SSR Vue SSR 介绍 是什么 官方文档:https://ssr.vuejs.org/ Vue SSR(Vue.js Server-Side Rendering) 是 Vue....
  • 浅谈对SSR的理解

    2020-10-23 21:40:35
    SSR的优势 更好的SEO(搜索引擎优化) 首屏加载速度更快 SSR的缺点 开发条件会受到限制,服务器端渲染只支持beforeCreate和created这两个钩子函数 当我们需要一些外部扩展库时需要特殊处理,服务端渲染应用程序也...
  • 服务端渲染SSR的理解

    2020-11-07 11:33:34
    服务端渲染SSR的理解 SSR服务端渲染Server Side Render就是当进行请求时,页面上的内容是通过服务端渲染生成的,浏览器直接显示服务端返回的HTML即可。 客户端渲染CSR 通常在构建一个普通的SPA单页应用时,就是构建...
  • 最近有小伙伴在后台给我留言:如何才能成功通过大厂面试,进入大厂,拿到高薪offer? 关于这些问题,有一个人最有发言权,因为在他的帮助下,不少小伙伴都梦想成真了! 他是谁? 他——九叔,九叔有多牛: ...
  • 在MATLAB中,计算回归问题的拟合优度(或判定系数)可用[B,BINT,R,RINT,STATS] = regress(Y,X)指令,其中的STATS的第一个返回值即为R2。 一般来说,R2在0到1的闭区间上取值,但在...R^2 = \frac {SSR}{SST} = 1- \f...
  • <p>Am trying ssr using laravel react js. While am using spatie ssr package for laravel. all configuration setup is done. but whenever i trying to run its throwing error <pre><code> public function ...
  • scrapy爬取ssr链接

    千次阅读 2019-08-24 21:13:23
    title: scrapy爬取ssr链接 date: 2019-08-23 15:53:58 categories: 爬虫 tags: scrapy selenium cover: https://www.github.com/OneJane/blog/raw/master/小书匠/3d21604af4ece8292ae728500ce2c4f7_hd.jpg 基于...
  • 理解vue ssr原理,自己搭建简单的ssr框架 前言 大多数Vue项目要支持SSR应该是为了SEO考虑,毕竟对于WEB应用来说,搜索引擎是一个很大的流量入口。Vue SSR现在已经比较成熟了,但是如果是把一个SPA...
  • electron-ssr-0.2.5.AppImage

    2019-05-31 15:26:09
    electron-ssr-0.2.5.AppImage
  • ssr协议原理探究(附工具)

    万次阅读 2018-03-09 13:49:27
    这几天免费的ssr频繁更换,找到的ssr源都是ssr://形式出现,我的软件需要使用json来配置,异常麻烦。 搜索不到相关的内容后决定自己写一个转换的小工具。 首先收集到的资料显示: ssr是这样加密的。 定义base64...
  • 更精确SSR的交点检测

    2020-03-07 00:53:26
    Unreal的SSR交点检测 关于 屏幕空间反射,可以参考文章很多,我觉得这篇写得还是蛮好的:Screen Space Glossy Reflections,借个图用用: 本文不考虑 粗糙度,也不考虑 多条反射射线,只借鉴一下 Unreal 引擎在处理...
  • 共用部分 import React ,{useState} from 'react' import {connect} from 'react-redux' import {getIndexList} from '../store/index' const Index = (props) => { let [count,setCount] = useState(1) ...
  • 不同SSR特性之间的优劣简要概述

    千次阅读 2019-05-17 14:42:15
    如果阁下对SSR特性(协议插件和混淆插件)以及加密方式不了解,建议先选择默认方式,并阅读此文章后再决定具体选择何种协议。 加密方式 目前rixCloud 支持以下的加密方式 CHACHA20(默认) AES-128-CFB AES-256-...
  • react ssr

    2020-10-26 17:17:01
    SSR介绍 Server Slide Rendering 服务端渲染 什么是服务端渲染 服务端渲染(Server-Side Render),是指将单页应用(SPA)在服务器端渲染为 HTML 片段,发送到浏览器,然后为其绑定状态与事件,成为完全可交互页面的...
  • 玩Google Webmasters的可能...网上搜解决方案出来的都是一堆额外的SSR框架,要上node,还看起来麻烦的要死。对于已经完成的项目,为了让搜索引擎爬虫能爬几个页面,又是改前端代码,又是改后端语言真的是郁闷。 一种...
  • 使用python建立SSR订阅服务器

    万次阅读 2019-03-23 11:11:40
    使用python建立SSR服务器 SSR链接解析 订阅服务器的文本格式 搭建服务器运行Python Base64 编码原理
  • 15分钟学会vue项目改造成SSR

    千次阅读 多人点赞 2019-12-16 18:01:24
    15分钟学会vue项目改造成SSR Ps:网上看了好多服务器渲染的例子,基本都是从0开始的,用Nuxt或者vue官网推荐的ssr方案(vue-server-renderer),但是我们在开发过程中基本上是已经有了现有的项目了,我们所要做的是...
  • React SSR 源码剖析

    2020-11-18 09:00:00
    关注「前端向后」微信公众号,你将收获一系列「用 ???? 原创」的高质量技术文章,主题包括但不限于前端、Node.js以及服务端技术写在前面上篇React SSR 之 API 篇细致介绍...
  • 关注「前端向后」微信公众号,你将收获一系列「用 ???? 原创」的高质量技术文章,主题包括但不限于前端、Node.js以及服务端技术写在前面上篇《SSR 它到底香不香?细数 SSR 的利...
  • electron-ssr

    2019-10-13 19:46:46
    electron-ssr-0.2.6.AppImage原网站的github已经关闭,但有人做了备份,不过防止备份的也删了大家还是最好自己下一个保险。安装时直接双击即可,如果没反应右键打开属性,勾选可执行文件即可,在双击即可正常安装。
  • 让vue-cli初始化后的项目集成支持SSR

    万次阅读 2017-11-14 18:56:23
    http://blog.myweb.kim/vue/%E8%AE%A9vue-cli%E5%88%9D%E5%A7%8B%E5%8C%96%E5%90%8E%E7%9A%84%E9%A1%B9%E7%9B%AE%E9%9B%86%E6%88%90%E6%94%AF%E6%8C%81SSR/?utm_campaign=ligang&utm_source=csdn&
  • SSR分子标记

    2013-03-01 11:01:42
    SSR分子标记
  • ssr acl文件

    2018-01-18 17:27:16
    共享一个ssr 的自定义规则文件。 共享一个ssr 的自定义规则文件。
  • VueSSR的一些理解和详细配置

    千次阅读 2019-07-19 21:28:08
    概念 流程图 这是具体的流程图,如何实现,后续配置会详解 编译图解 结合上面的流程图来理解编译的过程图,因为服务端渲染只是一个可以等待异步数据的预渲染,最终用户交互还是需要Client entry生成的js来控制,这...

空空如也

1 2 3 4 5 ... 20
收藏数 18,238
精华内容 7,295
关键字:

ssr