xinyin025/learn.lianglianglee.com
1
0
Fork 0
mirror of https://github.com/zhwei820/learn.lianglianglee.com.git synced 2025-09-17 08:46:40 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
learn.lianglianglee.com/专栏/白话设计模式 28 讲（完）/14 策略模式：怎么来不重要，人到就行.md.html
周伟 d9c5ffd627 u
2022-05-11 19:04:14 +08:00

856 lines
28 KiB
HTML
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<!DOCTYPE html>
<!-- saved from url=(0046)https://kaiiiz.github.io/hexo-theme-book-demo/ -->
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1.0, user-scalable=no">
<link rel="icon" href="/static/favicon.png">
<title>14 策略模式：怎么来不重要，人到就行.md.html</title>
<!-- Spectre.css framework -->
<link rel="stylesheet" href="/static/index.css">
<!-- theme css & js -->
<meta name="generator" content="Hexo 4.2.0">
</head>
<body>
<div class="book-container">
<div class="book-sidebar">
<div class="book-brand">
<a href="/">
<img src="/static/favicon.png">
<span>技术文章摘抄</span>
</a>
</div>
<div class="book-menu uncollapsible">
<ul class="uncollapsible">
<li><a href="/" class="current-tab">首页</a></li>
</ul>
<ul class="uncollapsible">
<li><a href="../">上一级</a></li>
</ul>
<ul class="uncollapsible">
<li>
<a href="/专栏/白话设计模式 28 讲（完）/00 生活中的设计模式：启程之前，请不要错过我.md.html">00 生活中的设计模式：启程之前，请不要错过我.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/01 监听模式：坑爹的热水器.md.html">01 监听模式：坑爹的热水器.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/02 适配模式：身高不够鞋来凑.md.html">02 适配模式：身高不够鞋来凑.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/03 状态模式：人与水的三态.md.html">03 状态模式：人与水的三态.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/04 单例模式：你是我生命的唯一.md.html">04 单例模式：你是我生命的唯一.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/05 职责模式：我的假条去哪了.md.html">05 职责模式：我的假条去哪了.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/06 中介模式：找房子问中介.md.html">06 中介模式：找房子问中介.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/07 代理模式：帮我拿一下快递.md.html">07 代理模式：帮我拿一下快递.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/08 装饰模式：你想怎么穿就怎么穿.md.html">08 装饰模式：你想怎么穿就怎么穿.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/09 工厂模式：你要拿铁还是摩卡.md.html">09 工厂模式：你要拿铁还是摩卡.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/10 迭代模式：下一个就是你了.md.html">10 迭代模式：下一个就是你了.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/11 组合模式：自己组装电脑.md.html">11 组合模式：自己组装电脑.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/12 构建模式：想要车还是庄园.md.html">12 构建模式：想要车还是庄园.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/13 克隆模式：给你一个分身术.md.html">13 克隆模式：给你一个分身术.md.html</a>
</li>
<li>
<a class="current-tab" href="/专栏/白话设计模式 28 讲（完）/14 策略模式：怎么来不重要，人到就行.md.html">14 策略模式：怎么来不重要，人到就行.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/15 命令模式：大闸蟹，走起！.md.html">15 命令模式：大闸蟹，走起！.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/16 备忘模式：好记性不如烂笔头.md.html">16 备忘模式：好记性不如烂笔头.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/17 享元模式：颜料很贵必须充分利用.md.html">17 享元模式：颜料很贵必须充分利用.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/18 外观模式：学妹别慌，学长帮你.md.html">18 外观模式：学妹别慌，学长帮你.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/19 访问模式：一千个读者一千个哈姆雷特.md.html">19 访问模式：一千个读者一千个哈姆雷特.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/20 生活中的设计模式：与经典设计模式的不解渊源.md.html">20 生活中的设计模式：与经典设计模式的不解渊源.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/21 生活中的设计模式：那些未完待续的设计模式.md.html">21 生活中的设计模式：那些未完待续的设计模式.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/22 深入解读过滤器模式：制作一杯鲜纯细腻的豆浆.md.html">22 深入解读过滤器模式：制作一杯鲜纯细腻的豆浆.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/23 深入解读对象池技术：共享让生活更便捷.md.html">23 深入解读对象池技术：共享让生活更便捷.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/24 深入解读回调机制：把你技能亮出来.md.html">24 深入解读回调机制：把你技能亮出来.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/25 谈谈我对设计模式的理解.md.html">25 谈谈我对设计模式的理解.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/26 谈谈我对设计原则的思考.md.html">26 谈谈我对设计原则的思考.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/27 谈谈我对项目重构的看法.md.html">27 谈谈我对项目重构的看法.md.html</a>
</li>
</ul>
</div>
</div>
<div class="sidebar-toggle" onclick="sidebar_toggle()" onmouseover="add_inner()" onmouseleave="remove_inner()">
<div class="sidebar-toggle-inner"></div>
</div>
<script>
function add_inner() {
let inner = document.querySelector('.sidebar-toggle-inner')
inner.classList.add('show')
}
function remove_inner() {
let inner = document.querySelector('.sidebar-toggle-inner')
inner.classList.remove('show')
}
function sidebar_toggle() {
let sidebar_toggle = document.querySelector('.sidebar-toggle')
let sidebar = document.querySelector('.book-sidebar')
let content = document.querySelector('.off-canvas-content')
if (sidebar_toggle.classList.contains('extend')) { // show
sidebar_toggle.classList.remove('extend')
sidebar.classList.remove('hide')
content.classList.remove('extend')
} else { // hide
sidebar_toggle.classList.add('extend')
sidebar.classList.add('hide')
content.classList.add('extend')
}
}
function open_sidebar() {
let sidebar = document.querySelector('.book-sidebar')
let overlay = document.querySelector('.off-canvas-overlay')
sidebar.classList.add('show')
overlay.classList.add('show')
}
function hide_canvas() {
let sidebar = document.querySelector('.book-sidebar')
let overlay = document.querySelector('.off-canvas-overlay')
sidebar.classList.remove('show')
overlay.classList.remove('show')
}
</script>
<div class="off-canvas-content">
<div class="columns">
<div class="column col-12 col-lg-12">
<div class="book-navbar">
<!-- For Responsive Layout -->
<header class="navbar">
<section class="navbar-section">
<a onclick="open_sidebar()">
<i class="icon icon-menu"></i>
</a>
</section>
</header>
</div>
<div class="book-content" style="max-width: 960px; margin: 0 auto;
overflow-x: auto;
overflow-y: hidden;">
<div class="book-post">
<p id="tip" align="center"></p>
<div><h1>14 策略模式：怎么来不重要，人到就行</h1>
<p>【故事剧情】</p>
<blockquote>
<p>Tony 在北京漂泊了三年，在这期间有很多的美好，也有很多心酸，有很多期待，也有很多失落；可终究还是要离开了，原因很简单：一来北京压力太大，生活成本太高；二来北京离家太远。离开北京，Tony 也没有回家，而是选择了新的城市——杭州。</p>
<p>Tony 并不是班里最早逃离北京的人，但却是毕业后仍然坚持做技术且由一线城市退居到二线城市最早的人（不是回老家或都转行）。Tony 还有十几个同学在北京，一说要离开北京，肯定是要和这些同学道别的。Tony 的学姐 Leaf（也是学校时的辅导员）为他精心组织和安排了一次聚餐，地点选在了健德门附近的一家江西餐饮——西江美食舫，大家约好晚上 19：00 不见不散……</p>
<p>时间和地点都定了，把能来的这些人建了一个群，大家便开始热闹地聊起来了：</p>
<p>Joe：我离那比较近，骑共享单车 15 分钟就到了，我可以先去点餐。</p>
<p>Helen：我坐地铁到那半小时，也没问题。</p>
<p>Henry：我有直达的快速公交到那 40 分钟，不过下班高峰期可能会堵车，时间不好说。</p>
<p>Ruby：我公司还有点事，可能会晚半个小时，到时我打车过去……</p>
<p>Leaf：<strong>怎么来不重要，人到就行！</strong></p>
<p>Tony：大家有心，万分感谢，安全最重要！</p>
</blockquote>
<p><img src="assets/fcffcb80-7827-11e8-9ada-255ab1257678.jpg" alt="img" /></p>
<h3>用程序来模拟生活</h3>
<p>随着社会的发展、时代的进步，出行交通的方式可谓是越来越多样，可以说是丰富到了千奇百怪的地步了。除了上面提到的共享单车、公交车、地铁、快车（或出租车），也可以是自驾、电动车、平衡车，甚至都可以踏个轮滑、踩个滑板过来！采用什么交通方式并不重要，重要的是你能准时来共聚晚餐，不然就只能吃残羹冷炙了，哈哈！下面用代码来模拟一下大家使用不同的出行方式参加聚餐的情景吧。</p>
<p>源码示例：</p>
<pre><code class="language-python">class IVehicle:
&quot;交通工具的抽象类&quot;
def running(self):
pass
class SharedBicycle(IVehicle):
&quot;共享单车&quot;
def running(self):
print(&quot;骑共享单车(轻快便捷)&quot;, end='')
class ExpressBus(IVehicle):
&quot;快速公交&quot;
def running(self):
print(&quot;坐快速公交(经济绿色)&quot;, end='')
class Express(IVehicle):
&quot;快车&quot;
def running(self):
print(&quot;打快车(快速方便)&quot;, end='')
class Subway(IVehicle):
&quot;地铁&quot;
def running(self):
print(&quot;坐地铁(高效安全)&quot;, end='')
class Classmate:
&quot;参加聚餐的同学&quot;
def __init__(self, name, vechicle):
self.__name = name
self.__vechicle = vechicle
def attendTheDinner(self):
print(self.__name + &quot; &quot;, end='')
self.__vechicle.running()
print(&quot; 来参加聚餐！&quot;)
</code></pre>
<p>测试代码：</p>
<pre><code class="language-python">def testTheDinner():
sharedBicycle = SharedBicycle()
joe = Classmate(&quot;Joe&quot;, sharedBicycle)
joe.attendTheDinner()
helen = Classmate(&quot;Helen&quot;, Subway())
helen.attendTheDinner()
henry = Classmate(&quot;Henry&quot;, ExpressBus())
henry.attendTheDinner()
ruby = Classmate(&quot;Ruby&quot;, Express())
ruby.attendTheDinner()
</code></pre>
<p>输出结果：</p>
<pre><code>Joe 骑共享单车(轻快便捷) 来参加聚餐！
Helen 坐地铁(高效安全) 来参加聚餐！
Henry 坐快速公交(经济绿色) 来参加聚餐！
Ruby 打快车(快速方便) 来参加聚餐！
</code></pre>
<p>上面示例的类图如下：</p>
<p><img src="assets/99aeddd0-7824-11e8-974f-33e8b8ec2777.jpg" alt="enter image description here" /></p>
<h3>从剧情中思考策略模式</h3>
<p>上面的示例中我们可以选择不同的出行方式去参加聚餐，可以骑共享单车，也可以坐公共汽车，亦或是踩一辆平衡车；选用什么交通工具不重要，重要的是能够实现我们的目标——准时到达聚餐的地点，我们可以根据自己的实际情况进行选择和更换不同的出行方式。这里，选择不同的交通工具，就相当于选择了不同的出行策略；在程序中也有这样一种类似的模式——策略模式。</p>
<h3>策略模式</h3>
<p>策略模式的定义：</p>
<blockquote>
<p>Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from the clients that use it.</p>
<p>定义一系列算法，将每个算法都封装起来，并且使他们之间可以相互替换。策略模式使算法可以独立于使用它的用户而变化。</p>
</blockquote>
<p>策略模式是对算法、规则的一种封装。如上面的示例中，可以将不同的出行方式（采用的交通工具）理解成一种出行算法，将这些算法抽象出一个基类 IVehicle，并定义一系列的算法，共享单车（SharedBicycle）、快速公交（ExpressBus）、地铁（Subway）、快车（Express）。我们可以选择任意一种（实际场景肯定会选择最合适的）出行方式，并且可以方便更换出行方式。如 henry 要把出行方式由快速公交改成快车，只需要调用出改一行代码即可。</p>
<pre><code class="language-python"># henry = Classmate(&quot;Henry&quot;, ExpressBus())
henry = Classmate(&quot;Henry&quot;, Express())
henry.attendTheDinner()
</code></pre>
<h3>策略模式的模型抽象</h3>
<h4>类图</h4>
<p>策略模式的类图表示如下：</p>
<p><img src="assets/dc59ab60-7824-11e8-81a3-e1036ee16107.jpg" alt="enter image description here" /></p>
<p>Context 是一个上下文环境类，负责提供对外的接口，与用户的交互，屏蔽上层对策略（算法）的直接访问，如示例中的 Classmate。Strategy 是策略（算法）的抽象类，定义统一的接口，如示例中的 IVehicle。StrategyA 和 StrategyB 是具体策略的实现类，如示例中 SharedBicycle、ExpressBus 等。</p>
<p>**注意：**algorithm() 方法并不是说只用来定义算法，也可以是一种规则、一个运作或一种行为（如方面示例中的 running 指的是交通工具的运行方式）。一个 Strategy 也可以有多个方法（如一种算法是多个步骤组成的）。</p>
<h4>模型说明</h4>
<h5><strong>设计要点</strong></h5>
<p>策略模式中主要三个角色，在设计策略模式时要找到并区分这些角色：</p>
<ul>
<li><strong>上下文环境（Context）：</strong> 起着承上启下的封装作用，屏蔽上层应用对策略（算法）的直接访问，封装可能存在的变化。</li>
<li><strong>策略的抽象（Strategy）：</strong> 策略（算法）的抽象类，定义统一的接口，规定每一个子类必须实现的方法。</li>
<li><strong>具备的策略：</strong> 策略的具体实现者，可以有多个不同的（算法或规则）实现。</li>
</ul>
<h5><strong>优缺点</strong></h5>
<p>策略模式的优点：</p>
<ul>
<li>算法（规则）可自由地切换。</li>
<li>避免使用多重条件判断。</li>
<li>方便拓展和增加新的算法（规则）。</li>
</ul>
<p>策略模式的缺点：所有策略类都需要对外暴露。</p>
<h3>实战应用</h3>
<p>假设有这样一个应用场景：</p>
<blockquote>
<p>有一 Person 类，有年龄（age）、体重（weight）、身高（height）三个属性。现要对 Person 的一组对象进行排序，但并没有确定根据什么规则来排序，有时需要根据年龄进行排序，有时需要根据身高进行排序，有时可能是根据身高和体重的综合情况来排序，还有可能……</p>
</blockquote>
<p>通过对这个应用场景进行分析，会发现，这里需要有多种排序算法，而且需要动态地在这几种算法中进行选择，相信你很容易就会想到策略模式。没错，想到这就对了！那我们来看一下具体的代码。</p>
<p><strong>源码示例：</strong></p>
<pre><code class="language-python">class Person:
&quot;人类&quot;
def __init__(self, name, age, weight, height):
self.name = name
self.age = age
self.weight = weight
self.height = height
def showMysef(self):
print(self.name + &quot; &quot; + str(self.age) + &quot; years old, &quot; + str(self.weight) + &quot;kg, &quot; + str(self.height) + &quot;m.&quot;)
class ICompare:
&quot;比较算法&quot;
def comparable(self, person1, person2):
&quot;person1 &gt; person2 返回值&gt;0，person1 == person2 返回0， person1 &lt; person2 返回值小于0&quot;
pass
class CompareByAge(ICompare):
&quot;通过年龄排序&quot;
def comparable(self, person1, person2):
return person1.age - person2.age
class CompareByHeight(ICompare):
&quot;通过身高进行排序&quot;
def comparable(self, person1, person2):
return person1.height - person2.height
class SortPerson:
&quot;Person的排序类&quot;
def __init__(self, compare):
self.__compare = compare
def sort(self, personList):
&quot;排序算法，这里采用最简单的冒泡排序&quot;
n = len(personList)
for i in range(0, n-1):
for j in range(0, n-i-1):
if(self.__compare.comparable(personList[j], personList[j+1]) &gt; 0):
tmp = personList[j]
personList[j] = personList[j+1]
personList[j+1] = tmp
j += 1
i += 1
</code></pre>
<p><strong>测试代码：</strong></p>
<pre><code class="language-python">def testSortPerson():
personList = [
Person(&quot;Tony&quot;, 2, 54.5, 0.82),
Person(&quot;Jack&quot;, 31, 74.5, 1.80),
Person(&quot;Nick&quot;, 54, 44.5, 1.59),
Person(&quot;Eric&quot;, 23, 62.0, 1.78),
Person(&quot;Helen&quot;, 16, 45.7, 1.60)
]
sorter0 = SortPerson(CompareByAge())
sorter0.sort(personList)
print(&quot;根据年龄进行排序后的结果：&quot;)
for person in personList:
person.showMysef()
print()
sorter1 = SortPerson(CompareByHeight())
sorter1.sort(personList)
print(&quot;根据身高进行排序后的结果：&quot;)
for person in personList:
person.showMysef()
</code></pre>
<p><strong>输出结果：</strong></p>
<pre><code>根据年龄进行排序后的结果：
Tony 2 years old, 54.5kg, 0.82m.
Helen 16 years old, 45.7kg, 1.6m.
Eric 23 years old, 62.0kg, 1.78m.
Jack 31 years old, 74.5kg, 1.8m.
Nick 54 years old, 44.5kg, 1.59m.
根据身高进行排序后的结果：
Tony 2 years old, 54.5kg, 0.82m.
Nick 54 years old, 44.5kg, 1.59m.
Helen 16 years old, 45.7kg, 1.6m.
Eric 23 years old, 62.0kg, 1.78m.
Jack 31 years old, 74.5kg, 1.8m.
</code></pre>
<p>上面的代码可用类图表示如下：</p>
<p><img src="assets/eee1eea0-7824-11e8-974f-33e8b8ec2777.jpg" alt="enter image description here" /></p>
<p>看到这，熟悉 Python 的读者肯定要吐槽了！Python 是一个简洁明了的语言，使用十几行代码就能解决的问题（如下面的实现代码），为什么要写上面这一大堆的东西。</p>
<pre><code class="language-python">from operator import itemgetter,attrgetter
def testPersonListInPython():
&quot;用Python的方式对Person进行排序&quot;
personList = [
Person(&quot;Tony&quot;, 2, 54.5, 0.82),
Person(&quot;Jack&quot;, 31, 74.5, 1.80),
Person(&quot;Nick&quot;, 54, 44.5, 1.59),
Person(&quot;Eric&quot;, 23, 62.0, 1.78),
Person(&quot;Helen&quot;, 16, 45.7, 1.60)
]
# 使用使用operator模块根据年龄进行排序
print(&quot;根据年龄进行排序后的结果：&quot;)
sortedPerons = sorted(personList, key = attrgetter('age'))
for person in sortedPerons:
person.showMysef()
print()
print(&quot;根据身高进行排序后的结果：&quot;)
sortedPerons1 = sorted(personList, key=attrgetter('height'))
for person in sortedPerons1:
person.showMysef()
</code></pre>
<p>输出的结果和上面是一模一样的，这里不再赘述。</p>
<p>能提出这个问题，说明你一定是带着思考在阅读！之所以还要这么写，出于以下几个原因：</p>
<ul>
<li>设计模式是一种编译思想，它和语言没有强关联，应当适用于所有面向对象的语言。Python 因为语言本身的灵活性和良好的封装性，使得其自带了很多的功能。而其他语言并没有这样的功能，为了让熟悉其他语言的人也能看懂，所以使用了最接近面向对象思维的方式进行实现（即使你熟悉 Python 也可通过它来学习一种新的思维方式）。</li>
<li>通过这种最本质的实现方式，有助于你更好地理解各种语言的 Sort 函数的原理。熟悉 Java 的同学，再看看 java.lang.Comparable 接口和 java.util.Arrays 中的 Sort 方法（public static void sort(Object[] a)），一定会有更深刻的理解，因为 Comparable 接口使用的就是策略模式，只不过该接口的实现者就是实体类本身（如上面例子中的 Person 就是实体类）。</li>
<li>使用 Python 语言本身的特性，还是难以实现一些特殊的需求，如要根据身高和体重的综合情况来排序（身高和体重的权重分别是 0.6 和 0.4）。用策略模式就可以很方便地实现，只需要增加一个 CompareByHeightAndWeight 的策略类就可以，如下面代码：</li>
</ul>
<pre><code class="language-python">class CompareByHeightAndWeight(ICompare):
&quot;根据身高和体重的综合情况来排序(身高和体重的权重分别是0.6和0.4)&quot;
def comparable(self, person1, person2):
value1 = person1.height * 0.6 + person1.weight * 0.4
value2 = person2.height * 0.6 + person2.weight * 0.4
return value1 - value2
</code></pre>
<h3>应用场景</h3>
<ul>
<li>如果一个系统里面有许多类，它们之间的区别仅在于有不同的行为，那么可以使用策略模式动态地让一个对象在许多行为中选择一种。</li>
<li>一个系统需要动态地在几种算法中选择一种。</li>
<li>设计程序接口时希望部分的内部实现由调用方自己实现。</li>
</ul>
</div>
</div>
<div>
<div style="float: left">
<a href="/专栏/白话设计模式 28 讲（完）/13 克隆模式：给你一个分身术.md.html">上一页</a>
</div>
<div style="float: right">
<a href="/专栏/白话设计模式 28 讲（完）/15 命令模式：大闸蟹，走起！.md.html">下一页</a>
</div>
</div>
</div>
</div>
</div>
</div>
<a class="off-canvas-overlay" onclick="hide_canvas()"></a>
</div>
<script defer src="https://static.cloudflareinsights.com/beacon.min.js/v652eace1692a40cfa3763df669d7439c1639079717194" integrity="sha512-Gi7xpJR8tSkrpF7aordPZQlW2DLtzUlZcumS8dMQjwDHEnw9I7ZLyiOj/6tZStRBGtGgN6ceN6cMH8z7etPGlw==" data-cf-beacon='{"rayId":"70997b99ca123cfa","version":"2021.12.0","r":1,"token":"1f5d475227ce4f0089a7cff1ab17c0f5","si":100}' crossorigin="anonymous"></script>
</body>
<!-- Global site tag (gtag.js) - Google Analytics -->
<script async src="https://www.googletagmanager.com/gtag/js?id=G-NPSEEVD756"></script>
<script>
window.dataLayer = window.dataLayer || [];
function gtag() {
dataLayer.push(arguments);
}
gtag('js', new Date());
gtag('config', 'G-NPSEEVD756');
var path = window.location.pathname
var cookie = getCookie("lastPath");
console.log(path)
if (path.replace("/", "") === "") {
if (cookie.replace("/", "") !== "") {
console.log(cookie)
document.getElementById("tip").innerHTML = "<a href='" + cookie + "'>跳转到上次进度</a>"
}
} else {
setCookie("lastPath", path)
}
function setCookie(cname, cvalue) {
var d = new Date();
d.setTime(d.getTime() + (180 * 24 * 60 * 60 * 1000));
var expires = "expires=" + d.toGMTString();
document.cookie = cname + "=" + cvalue + "; " + expires + ";path = /";
}
function getCookie(cname) {
var name = cname + "=";
var ca = document.cookie.split(';');
for (var i = 0; i < ca.length; i++) {
var c = ca[i].trim();
if (c.indexOf(name) === 0) return c.substring(name.length, c.length);
}
return "";
}
</script>
</html>
Reference in New Issue View Git Blame Copy Permalink