前端、数据库、Django简单的练习

一、前端

1、前端页面由哪几层构成，分别是什么，作用是什么？

　　分为：结构层（html），表示层（css），行为层（js）。

　　结构层

　　超文本标记语言。由HTML或XHTML之类的标记语言负责创建。标签，也就是那些出现在括号里的单词，对网页内容的语义做出了描述，但这些标签不包含任何关于如何显示有关内容的信息。例如：p标签表达了这样一种语义：“这是一个文本段。”

　　表示层

　　层叠样式表。由css负责创建。css对“如何显示有关内容”的问题做出了回答。

　　行为层

　　客户端脚本语言。负责回答“内容应该如何对事件做出反应”这一问题。这是JavaScript语言和DOM主宰的领域。

2、html中总共有几类标签的？分别描述一下它们的不同？

　　块级标签、内联标签、内联块状标签（img、input）。

　　内联标签不能包含块级标签，块级标签能够包含内联标签也能够包含块级标签（除了p元素，p元素不能相互包含，但是p元素能够包含其他元素。）

3、display：none和visibility：hidden的区别？

　　a）display：none是彻底消失，不在文档流中占位，浏览器不会解析该元素；visibility：hidden是视觉上消失了，在文档流中会占位，浏览器会解析该元素。

　　b）使用visibility：hidden比display：none性能上要好，display切换显示时页面会产生回流（当页面中的一部分元素需要改变规模尺寸、布局、显示隐藏等，页面重新构建，此时就是回流）而visibility切换显示时则不会引起回流。

4、input标签都有哪些类型，input标签都有哪些属性？

　　类型：button、checkbox、file、hidden、image、password、radio、reset、submit、text

　　属性：type、required、pattern（输入内容必须完全匹配正则表达式）、placeholder（提示输入）、disabled（禁用）、name、id、style。

5、阐述一下css定位有几种？并分别描述它们的不同。

　　relative（相对定位）：相对定位的偏移参考元素是元素本身，不会使元素脱离文档流。元素的初始位置占据的空间会被保留。相对定位元素常常作为绝对定位元素的父元素。并且定位元素经常与z-index属性进行层次分级

　　absolute（绝对定位）：绝对定位元素以父辈元素中最近的定位元素为参考坐标，如果绝对定位元素的父辈元素中没有采用定位的，那么此绝对定位元素的参考对象是html,元素会脱离文档流。就好像文档流中被删除了一样。并且定位元素经常与z-index属性进行层次分级

　　position：fixed（固定）：位移的参考坐标是可视窗口，使用fixed的元素脱离文档流。并且定位元素经常与z-index属性进行层次分级

　　position：static（静态定位）：默认值，元素框正常生成的，top left bottom right这几个偏移属性不会影响其静态定位的正常显示

6、js的基础数据类型有哪些？Null和Undefined的区别？

　　基础数据类型：Undefined、Null、String、Number、Boolean。引用类型有这几种：object、Array、RegExp、Date、Function、特殊的基本包装类型(String、Number、Boolean)以及单体内置对象(Global、Math)。

　　 Null和Undefined的区别：

　　null表示“没有对象”，即该处不该有值。典型用法：　

　　（1） 作为函数的参数，表示该函数的参数不是对象。

　　（2） 作为对象原型链的终点。

　　undefined表示“缺少值”，就是此处应该有一个值，但是还没有定义。典型用法是：

　　（1）变量被声明了，但没有赋值时，就等于undefined。

　　（2) 调用函数时，应该提供的参数没有提供，该参数等于undefined。

　　（3）对象没有赋值的属性，该属性的值为undefined。

　　（4）函数没有返回值时，默认返回undefined。

7、列出jQuery常用的选择器

　　基本css选择器：元素选择器、类选择器、ID选择器。

　　上下文选择器：后代选择器、儿子选择器、兄弟选择器、毗邻选择器

8、事件委托是什么？

　　事件委托是利用事件的冒泡原理来实现的，何为事件冒泡呢？就是事件从最深的节点开始，然后逐步向上传播事件，举个例子：页面上有这么一个节点树，div>ul>li>a;比如给最里面的a加一个click点击事件，那么这个事件就会一层一层的往外执行，执行顺序a>li>ul>div，有这样一个机制，那么我们给最外面的div加点击事件，那么里面的ul，li，a做点击事件的时候，都会冒泡到最外层的div上，所以都会触发，这就是事件委托，委托它们父级代为执行事件。　

二、数据库

1、数据库的字段类型有哪些？

　　二进制数据类型：Binary、Varbinary、Image

　　字符数据类型：Char，Varchar、text

　　Unicode数据类型：Nchar、Nvarchar、Ntext

　　日期和时间数据类型：数字数据类型包括正数和负数、小数和整数

　　smallint、int、bigint

2、说说你所知道的MySQL数据存储引擎，InnoDB存储引擎和MyISM存储引擎的区别？

　　MySQL中常用的几种存储引擎：MyISAM、InnoDB、bdb、MEMORY，　

　　MyISAM存储引擎:
　　MyISAM 这种存储引擎不支持事务，不支持行级锁，只支持并发插入的表锁，主要用于高负载的select。所以其写入的并发处理能力相对较弱。
　　MyISAM类型的数据表（.MYD文件）支持三种不同的存储结构：静态型、动态型、压缩型。
静态型：就是定义的表列的大小是固定（即不含有：xblob、xtext、varchar等长度可变的数据类型），这样mysql就会自动使用静态myisam格式。
　　使用静态格式的表的性能比较高，因为在维护和访问的时候以预定格式存储数据时需要的开销很低。但是这高性能是有空间换来的，因为在定义的时候是固定的，所以不管列中的值有多大，都会以最大值为准，占据了整个空间。

　　innoDB存储引擎：

　　同MyISAM一样的是，InnoDB存储引擎也有.frm文件存储表结构定义
　　innodb存储引擎该mysql表提供了事务，回滚以及系统崩溃修复能力和多版本并发控制的事务的安全。
　　InnoDB有支持事务及安全的日志文件，这个文件非常重要，InnoDB可以通过日志文件将数据库崩溃时已经完成但还没来得及将内存中已经修改但未完全写入磁盘的数据写入磁盘，也可以把已部分完成并写入磁盘的未完成事务回滚，保证数据一致性。如果错误删除日志文件会导致数据库崩溃且无法启动。
　　innodb支持自增长列（auto_increment）,自增长列的值不能为空，如果在使用的时候为空的话就会进行自动存现有的值开始增值，如果有但是比现在的还大，则就保存这个值。
innodb存储引擎支持外键（foreign key） ,外键所在的表称为子表而所依赖的表称为父表。

3、索引的本质是什么？索引有什么优点？缺点是什么？

　　索引（Index）是帮助MySQL高效获取数据的数据结构。

　　优点：

　　第一，通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
　　第二，可以大大加快数据的检索速度，这也是创建索引的最主要的原因。
　　第三，可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
　　第四，在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
　　第五，通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。
　   缺点：

　　第一，创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
　　第二，索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大。
　　第三，当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。

4、char和varchar的区别，varchar(50)和char(50)分别代表什么意思？

　　char的长度是不可变的，而varchar的长度是可变的。

　　char的存取数度还是要比varchar要快得多，因为其长度固定，方便程序的存储与查找；但是char也为此付出的是空间的代价，因为其长度固定，所以难免会有多余的空格占位符占据空间，可谓是以空间换取时间效率，而varchar是以空间效率为首位的。

5、简述你对inner join、left join、right join的理解。

　　inner join（内连接），在两张表进行连接查询时，只保留两张表中完全匹配的结果集。

　　left join（左连接）,在两张表进行连接查询时，会返回左表所有的行，即使在右表中没有匹配的记录。

　　right join（右连接）,在两张表进行连接查询时，会返回右表所有的行，即使在左表中没有匹配的记录。

　　full join（全连接）,在两张表进行连接查询时，返回左表和右表中所有没有匹配的行。

三、数据库

1、写出你所知道的Django有关的所有命令（下载、安装等）。　　

1. Django的安装

　　pip install django ==1.11.11

　　pip install -i yuan django==1.11.11

2. 创建项目

　　django-admin startproject  项目名

通过manage.py执行

CD项目目录下

3.创建APP

　　python manage.py startapp app01

4. 启动项目

　　python manage.py runserver # 127.0.0.1:8000

　　python manage.py runserver 80 # 127.0.0.1:80

　　python manage.py runserver 0.0.0.0: 80 # 0.0.0.0:80

5. 数据库相关

　　python manage.py makemigrations # 记录modeles 的变化，将变更记录到 对应APP 下的 migrations

　　python manage.py migrate  # 翻译成SQL语句，去数据库执行

-------------------------------------------------------------我是下划线-----------------------------------------------------

配置settings.py

1. 数据库相关

　　EGNIGE:　　引擎 mysql sqllite3

　　NAME:　　　数据库名字

　　HOST:　　　IP

　　POST: 　　　端口号 3306

　　USER:　　　用户名

　　PASSWORD:　　密码      ‘ ’

2. 静态文件相关

　　STATIC_URL= ‘static’  # 别名

　　STATICFILES_DIRS = [

　　os.path.join(BASE_DIR,'STATIC'),　　

]

3. APP

　　INSTALLED_APPS = [

　　'app01.apps.App01Config',    #告诉 Django我自己新建了一个名叫app01的应用

　　# ‘app01’

]

4. CSRF

　　注释掉CSRF中间件 　　form表单可以提交POST请求

5. TEMPLATES

　　'DIRS':[os.path.join(BASE_DIR,'TEMPLATES')]

----------------------------------------------------------我是下划线--------------------------------------------------------

ORM的对应关系

　　类 　　 --------　　数据表

　　对象　  --------　　数据行

　　属性　  --------　　字段

-----------------------------------------------------我是下划线------------------------------------------------------

Django使用mysql数据库的步骤：

　　1.手动创建mysql数据库

　　2. 在settings.py中配置：

　　　　DATABASES = {

　　　　　　　　'default':{

　　　　　　　　　　'ENGINE': 'django.db.background.mysql',　　# 连接数据库的类型

　　　　　　　　　　'NAME': 'mysite'　　# 数据库名

　　　　　　　　　　'HOST': '127.0.0.1', # 数据库主机地址

　　　　　　　　　　'POST':  3306 　　# 数据库的端口

　　　　　　　　　　'USER': 'root',

　　　　　　　　　　'PASSWORD': ' ',

　　　　　　　　　　}

　　　　　　　　}

　　3. 告诉Django使用pymysql连接数据库

　　　　在于settings.py 文件同级的目录下的__init__.py写代码：

　　　　　　import pymysql

　　　　　　pymysql.install_as_MySQLdb()

　　4. 在models.py中写类（继承models.Model）

　　　　class Press(models.Model):

　　　　　　id = models.AutoField(primary_key=True)　　# id主键

　　　　　　name = models.CharField(max_length=32)　 # 出版社名称

　　　　　　

　　　　　　def __str__(self):

　　　　　　　　return '<这是一个出版社对象，它的名字是：{}>'.format(self.name)

　　　　　　# 　　书

　　　　　　class Book(models.Model):

　　　　　　　　id = models.AutoField(primary_key=True) 　　#自增ID主键

　　　　　　　　title= models.CharField(max_length=30)　　　# 书名

　　　　　　　　price = models.IntegerField()　　　　　　　　# 价格

　　　　　　　　# Django 1.11 默认就是级联删除 ， Django2.0 之后必须指定on_delete

　　　　　　　　# to=关联的表名

　　　　　　　　press　= 　models.ForeignKey('Press_on_delete=models.CASCADE')

　　　　　　#　　作者

　　　　　　class  Author(models.Model):

　　　　　　　　id = models.AutoField(primary_key=True)　　# 自增ID主键

　　　　　　　　name = models.CharField(max_length=32)　 # 作者名字

　　　　　　　　books = models.ManyToManyField(to='book') # 只是ORM层面建立的一个多对多关系，不是作者表的一个字段

　　　　　　　　

　　　　　　　　def __str__(self):

　　　　　　　　　　return self.name

　　5. 执行命名

　　　　python manage.py makemigrations　　# 记录models的变化，将变更记录到 对应APP下的migrations

　　　　python manage.py migrate　　　　　 #  翻译成SQL语句，去数据库执行

-----------------------------------------------------我是下划线--------------------------------------------------------

ORM操作

　　1. 查：

　　　　from app01.models import User,Press,Book,Author

　　　　Press.objects.all()　　# 查询所有出版社对象 ------  对象列表 queryset

　　　　Press.objects.filter(条件)　　# 查询所有满足条件的出版社对象  ------ 对象列表 queryset

　　　　Press.objects.get(条件)　　  # 查询有且只能有一个对象　　没有或者多个都报错 ---- 对象

　　　　

　　　　属性：

　　　　　　press_obj.id

　　　　　　press_obj.name

　　　　外键：

　　　　　　book_obj.id

　　　　　　book_obj.title

　　　　　　book_obj.press　　　　-------关联的对象

　　　　　　book_obj.press_id　　  -------数据库中的关联对象的ID

　　　　　　book_obj.press.id

　　　　多对多：

　　　　　　author——obj.books　  ------管理对象

　　　　　　author_obj.books.all()　------作者关联的所有书籍对象

　　2. 增加：

　　　　new_obj = Press.objects.create(name='新的出版社')

　　　　Book.objects.create(title='书名'，price = 15,press=press_obj)

　　　　Book.objects.create(title='书名',price=15,press_id=press_obj.id)

　　

　　　　new_obj = Author.objects.create(name='作者名')

　　　　new_obj.books.set([1,2,3])

　　　　new_obj.books.set([book1,book2])

　　　　new_obj.books.add(1,2,3)

　　3. 删除

　　　　book_obj.delete() 　　------删除单个对象

　　　　Press.objects,filter(条件).delete()   -------删多个对象

　　4. 编辑

　　　　press_obj.name = '新的出版社名字'

　　　　press_obj.save()

　　　　

　　　　book_obj.press = press_obj

　　　　# book_obj.press_id = press_obj.id

　　　　book_obj.save()

　　　　author_obj.name = '作者名'
　　　　author_obj.save()

　　　　

　　　　author_obj.books.set([1,2,3])

2、Django的settings中，你用到的配置项有哪些？它们的作用是什么？

TEMPLATE_DIRS

模板文件存放的目录.该值是一个元组.

STATIC_URL

映射到静态文件的url，一般为/static/.
在模板中使用{{STATIC_URL}},得到的就是这个值.
或者在模板中先{% load staticfiles %},然后使用{% static “my_app/abc.jpg” %},该模板标签的值为/static/my_app/abc.jpg
最好使用nginx代理该url,访问静态文件时不通过django,而是直接由nginx访问.
注意:如果用ngxin代理的话,那么每次修改static文件,都需要执行一遍collectstatic命令

STATICFILES_FINDERS

默认该值如下:
‘django.contrib.staticfiles.finders.FileSystemFinder’,
‘django.contrib.staticfiles.finders.AppDirectoriesFinder’
FileSystemFinder告诉django从STATICFILES_DIRS设置的所有目录下寻找静态文件
AppDirectoriesFinder告诉Django从INSTALLED_APPS中每一个app下的static/ 子目录下去寻找静态文件

STATIC_ROOT

是总的static目录，可以使用命令自动收集static文件
使用命令python manage.py collectstatic收集静态文件,将所有静态文件复制到STATIC_ROOT设置的目录下.

STATICFILES_DIRS

是个元组,每一项都是静态文件存放的目录.
当执行collectstatic命令时,会将STATICFILES_DIRS下的所有静态文件收集到STATIC_ROOT目录下.

3、Django使用MySQL数据库的流程是什么？

4、分别定义一个FBV和CBV，以及它们的路由？

　　FBV

　　from django.shortcuts import render

 

　　def index(req):

    if req.method == ‘POST‘:

        print(‘method is :‘ + req.method)

    elif req.method == ‘GET‘:

        print(‘method is :‘ + req.method)

    return render(req, ‘index.html‘)

　　url(r‘^index/‘, views.index),

　　CBV　

　　from django.views import View

 

　　class Index(View):

    def get(self, req):

        print(‘method is :‘ + req.method)

        return render(req, ‘index.html‘)

 

    def post(self, req):

        print(‘method is :‘ + req.method)

        return render(req, ‘index.html‘)

　　url(r‘^index/‘, views.Index.as_view()),

5、写出你知道的request对象的方法和属性。

request对象的方法：　

1.HttpRequest.get_host()——（根据从HTTP_X_FORWARDED_HOST（如果打开 USE_X_FORWARDED_HOST，默认为False）和 HTTP_HOST

                                                                                                                头部信息返回请求的原始主机。）

2.HttpRequest.get_full_path()——（返回 path，如果可以将加上查询字符串。）

3.HttpRequest.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)——（返回签名过的Cookie 对应的值，如果签名

                                                                                                                                                  不再合法则返回django.core.signing.BadSignature。）

4.HttpRequest.is_secure()
——（如果请求时是安全的，则返回True；即请求通是过 HTTPS 发起的。）

5.HttpRequest.is_ajax()——（如果请求是通过XMLHttpRequest 发起的，则返回True，方法是检查 HTTP_X_REQUESTED_WITH

                                               相应的首部是否是字符串'XMLHttpRequest'。）

request对象的属性：

0.HttpRequest.scheme（表示请求方案的字符串）

1.HttpRequest.body（一个字符串，代表请求报文的主体）

2.HttpRequest.path（一个字符串，表示请求的路径组件（不含域名））

3.HttpRequest.method（一个字符串，表示请求使用的HTTP 方法。必须使用大写。）

4.HttpRequest.encoding（一个字符串，表示提交的数据的编码方式）

5.HttpRequest.GET（一个类似于字典的对象，包含 HTTP GET 的所有参数）

6.HttpRequest.POST（一个类似于字典的对象，如果请求中包含表单数据，则将这些数据封装成 QueryDict 对象。）

7.HttpRequest.COOKIES（一个标准的Python 字典，包含所有的cookie。键和值都为字符串。）

8.HttpRequest.FILES（一个类似于字典的对象，包含所有的上传文件信息。）

9.HttpRequest.META（一个标准的Python 字典，包含所有的HTTP 首部）

10.HttpRequest.user（一个 AUTH_USER_MODEL 类型的对象，表示当前登录的用户。）

11.HttpRequest.session（一个既可读又可写的类似于字典的对象，表示当前的会话）

6、如何在URLconf中给url命名？在视图和模板中如何使用url反向解析？

　　urlpatterns = patterns('', (r'^mydata/(?P<id>\d+)/$', views.my_view, {'id':3}), )

　　在模板（可以理解为HTML文件）里面可以这样引用：

{% url "home" %}　　

　　在views函数中可以这样引用：

from django.urls import reverse

redirect(reverse("index",args=("2018", )))

7、请写出你所知道的模板语法。

　　一、模板语法之变量：语法为 {{ }}：

　　{{ d.name }}

　　{{ person_list.1.name }}

　　二、模板语法之标签：语法为 {% tag  %}：

　　1、for标签（注：循环序号可以通过｛｛forloop｝｝显示）

　　2、for....empty ：for 标签带有一个可选的{% empty %} 从句，以便在给出的组是空的或者没有被找到时，可以有所操作。

{% for person in person_list %}
    <p>{{ person.name }}</p>

{% empty %}
    <p>sorry,no person here</p>
{% endfor %}

　　3、if标签 ：{% if %}会对一个变量求值，如果它的值是“True”（存在、不为空、且不是boolean类型的false值），对应的内容块会输出。

{% if i > 300 %}
    <p>大于{{ i }}</p>
{% elif i == 200  %}
    <p>等于{{ i }}</p>
{% else %}
    <p>小于{{ i }}</p>
{% endif %}

　　4、with：使用一个简单地名字缓存一个复杂的变量，当你需要使用一个“昂贵的”方法（比如访问数据库）很多次的时候是非常有用的

{% with total=business.employees.count %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}

<p>{{ person_list.2.name }}</p>
{% with name=person_list.2.name %}
    <p>{{ name }}</p>
{% endwith %}

　　5、csrf_token：这个标签用于跨站请求伪造保护

<h3>scrf_token</h3><form action="/tag/" method="post">
    {% csrf_token %}
    <p><input type="text" name="haiyan"></p>
    <input type="submit">
</form>

8、请写出模板和继承的使用方法。

1）继承使用

　　　　步骤1：母板里写入block，就可以被继承，content是名称　

    {% block title %}
    {% endblock%}

    {% block “content“ %}
    {% endblock%}

　　　　步骤2：子页面通过extends指定继承那个模板

    {% extends 'master.html'%} #继承那个模板

    {% block “content“ %} 这个地方就是替换模板block “content“
        <ul>
            {% for i in u%}
                <li>{{i}}</li>
            {%endfor%}
    {% endblock%}

2)一个页面只能继承一个模板，如何解决了？如何使用多个模板，或者引入其他页面

　　　　<% include "a.html" %> 可以引用多次

9、请写出自定义filter的步骤。

10、cookie和session是什么？为什么要使用它们？　　

　　一、为什么要用Cookie和Session？

很多时候客户端和服务器进行交互使用了HTTP协议，但是HTTP协议是无状态的；HTTP协议的请求过程，是基于 TCP/IP 的，当客户端请求服务器，服务器处理后，进行响应，该过程是无状态的。

但是在有些时候是需要保存一些客户端的请求信息，识别客户端的某些状态，智能的、有针对性的去分析某些客户端的习惯。这些时候，就需要去记录客户端的连接状态，识别请求的状态等。所以为了解决类似的事情，就需要使用到了 Cookie 和 Session。

比如，使用Cookie的场景：有些网站有记住用户名的功能，当你勾这个的时候，下次进入该网站时，就会保存上一次登录的用户名；使用Seesion的场景：利用Seesion来验证用户是否已登录，利用Session来保存验证码。

　　二、Cookie和Session是什么？

（1）Cookie：在客户端访问某个地址时，会将请求交到服务器进行处理，在发送请求的时候，浏览器会将页面的头部信息一并的交到服务器端进行处理。在处理的过程中，Cookie 在服务器端生成 ，在此同时，可以将一些需要保存的信息，存放到此 Cookie 中。生成 Cookie 对象时，需要确定具体的名称及具体的值，可以设置当前 Cookie 的过期时间，设置过期时间后，就相当于持久化了 Cookie 中的数据，此时的 Cookie 会以之前的 Cookie 名称，保存在客户端。
如果不设置过期时间，则当前 Cookie 的生命期是浏览器会话期间，一旦关闭了该浏览器，当前的Cookie 就会不存在了，此时的 Cookie
信息是保存在内存中。在服务器端，处理完后，会将生成的 Cookie ，随着 Http 响应，会在 Http 响应头中，加上Cookie
信息，浏览器接受到响应后，会按照 Http 响应头里的 Cookie ，在客户端建立 Cookie 。在下次客户进行请求的时候，Http
会附带着已经存储过的 Cookie，一并发送到服务器。一个域，在客户端建立的所以 Cookie 都是可以共享的，只要 Cookie 没有过期。

（2）Session：Session 是在服务器端生成的，存储在服务器端，即存在内存中。可以对生成的 Session
设置过期时间，如果不设置过期时间，默认的 Session 过期时间是30 分钟（在不同的服务器中，它的过期时间略有不同，本文是以 Tomcat
来说的）  但是，Sesssion 的生成的同时，会生成一个与之相关联的的 SessionID ，此 SessionID的存储是需要
Cookie 来完成的。 SessionID 是以名称为
JSESSIONID，其值应该是一个既不会重复，又不容易被找到规律以仿造的字符串。SessionID会随着此次 Http
响应，一并返回到客户端，并保存在客户端中。到当前请求再次发出后，该 SessionID会随着 Http 头部，传到服务器中，服务器依据当前
SessionID 得到与之对应的 Session.

其中：通过 Cookie 的方式存储 Session 状态，只是其中一种方式。如果客户端禁用了 Cookie
的话，很多网站任然可以存储用户的信息。一种处理的方式是URL 重写，将 SesseionID
直接附加在请求地址的后面。另一种处理的方式是，使用隐藏自动的方式。就是服务器自动的在表单中，添加一个隐藏字段，以便在表单提交时，将
SesseionID 一起传到服务器，进行识别。