Python实现多任务

进程

1、创建进程

导入进程包

import multiprocessing

通过进程类创建对象

进程对象名 = multiprocessing.Process(参数)
//参数有 target代表执行的目标任务名其实就是是函数，arg以元组的形式为target传参，kwargs以字典的形式为target传参
//name代表进程名，group代表进程组

启动进程

进程对象.start()

2、获取进程编号

（1）获得当前进程编号

import os
os.getpid()

（2）获得父类的进程编号

import os
os.getppid()

3、主进程和子进程的关系

        主进程和子进程是相互独立的关系，实质上是主进程的资源重新分配的主进程和子进程中，他们两个全局变量的名称一样，但却不是一个全局变量，即主进程和子进程不共享全局变量。

        主进程和子进程的结束顺序：主进程会等待所有的子进程执行结束再结束。

线程

简介

进程是资源分配的最小单位，一旦创建一个进程就代表着会分配一定的资源，就好比用qq跟两个人聊天，需要打开两个qq。

线程是程序执行的最小单位，进程是线程的容器，一个进程最少有一个线程来执行程序。线程不拥有系统资源，只需要一点必不可少的资源即可运行，且在同一个进程中的线程共享该进程中的全部资源。

一个py文件就代表一个进程，在py文件的函数中，就可以使用多线程。

创建线程

（1）导入线程模块

import  threading

（2） 创建线程对象

线程对象  =  threading.Thread(target = 任务名)

其参数和进程一样。

 （3）执行线程

线程对象.start()

主线程和子线程的结束顺序：

（1）默认情况下，主子线程的结束顺序与进程相同。

（2）若想要设置主线程不等待子线程，可以设置守护主线程。

第一种方式：

线程对象  =  threading.Thread(target = 任务名 ，daemon = True)

通过将参数daemon设置成True来设置守护主线程

第二种方式：

线程对象.setDaemon(True)

（3）同一进程下的线程共享全局变量。

（4）由于线程之间共享全局变量，那么当同时调用全局变量时可能就会出错。为了避免出错，可以使用线程同步，即安排顺序，保证同一时刻只有一个线程去调用全局变量。实现线程同步的方法之一就是：互斥锁。

（5）互斥锁

创建互斥锁：

mutex  =  thread.Lock()

上锁：

mutex.acquire()

解锁：

mutex.release()

（6）当一直等待对方释放锁的情景就是死锁。这会造成程序无法相应其他命令，不在处理其他的任务。

 线程的执行顺序：

1、线程之间的执行顺序是无序的。

2、获取当前线程的信息。

threading.current_thread()

数据库（MySQL）

数据库基础知识：

主键：唯一标识一行记录的字段

字段：一列数据类型相同的数据（数据列）

记录：一行记录某个事物的完整信息的数据（数据行）

数据表：数据行的集合

数据库：数据表的集合

Navicat

 MySQL数据类型

（1）整型：

（2）浮点型：

float：单精度，只保证6位有效数字

double：双精度，只保证16位有效数字

decimal：定点数。例如decimal（5，2）表示共5位数字，其中两位是小数（888.88）

（3）字符串：

 char是定长，varchar是不定长。

text与char和varchar不同的是，text不可以有默认值，最大长度是2的16次方-1

（4）枚举类型

enum，在定义字段时就预告规定好固定的几个值，然后插入记录时只能在这几个固定好的值中选择一个。

语法： gender  enum('男','女')

（5）时间类型

数据完整性和约束

数据完整性指的是当一个数据存在于多个表中的时候，删除一个表的数据，其他表的数据也会随之消失。完整性要保证数据的正确性。

约束：保证数据的完整性和一致性。

 数据库的命令（不区分大小写）

连接数据库：mysql  -u用户名  -p密码;

退出数据库：exit / quit;

查看所有数据库： show  databases;

查看当前使用的数据库： select  database();

创建数据库： create  database  数据库名  charset=utf8;

使用数据库：use  数据库名;

删除数据库：drop  database  数据库名;

查看当前数据库的所有表：show  tables;

查看表的结构： desc  表名;

查看表的创建语句-详细过程：show  create  table  表名;

创建表：create  table  数据表名字 （字段  类型  约束 [, 字段  类型  约束]);

                int  unsigned:无符号整型

                auto_increment : 表示自动增长

                not null : 表示不能为空

                primary kry : 设置成主键

                default : 默认值

                例如：

·                create  table   xxx(

                id  int unsigned  primary key  auto_increment   not null,

                name  varchar(20)

                )

表结构的修改：

添加字段： alter  table 表名  add  列名  类型；

重命名字段：alter  table  表名  change  原名  新名  类型及约束;

修改字段类型：alter  table  表名  modify  列名  类型及约束

删除字段：  alter table  表名  drop  列名；

删除表： drop  table  表名；

添加数据：

全列插入：值的顺序与表结构字段的顺序完全一一对应 : insert  into  表名 values (...);

部分列插入：值的顺序与给出的列顺序对应 :  insert into  表名 （列1,...） values (值1,...)

一次性插入多行数据：insert  into  表名 values(...),(...)...;

部分列多行插入: insert  into  表名(列1,...) values(值1,...),(值1,...)...;

修改,查询数据：

查询所有列数据：select * from  表名；

查询指定列数据：select  列1，列2，... from 表名；

修改数据：update 表名 set 列1=值1，列2=值2...    where 条件;

删除数据：delete from 表名 where 条件;

where条件语句

1、where的比较运算查询，就是使用比较运算符。

2、逻辑运算查询，就是and  or  not

3、模糊查询like，like后面跟的是%表示任意多个任意字符，后面跟的是_表示一个任意字符

        例如查询小为开头的名字：select *  from  students where name like "小%"

                查询有小的所有名字：select * from students where name like "%小%"

                查询有两个字的名字：select * from students where name like "__"（双下划线）

4、范围查询：用的是between   and 对应的是[A , B](前后都是闭的)

5、判断为空 ：is null。     判断为非空： is  not null

6、排序查询语法:order

select * from 表名 order by 列1  asc|desc [,列2 asc|desc,...]

7、聚合函数：

group 分组

group by分组：将查询结果按照1个或者多个字段进行分组，字段值相同的为一组。group by可用于单个字段分组，也可用于多个字段分组。

例如：计算每种性别中的人数

select  gender,count(*)  from  students  group  by  gender

   查询同种性别的姓名

select  group_concat(name)  from strdents group by gender

而不是这样 select  gender,name  from students  group by gender（group by后面是什么字段，前面的select就只能查询哪个字段）

查询平均年龄超过30岁的性别，以及姓名（这里用到的不是where，而是having）

selecr group_concat(name),gender from students group by gender having avg(age) > 30

limit限制查询

limit限制取出记录的数量，但limit要写在sql语句的最后。

语法： limit  起始记录，记录数

说明：起始记录是指从第几条记录开始取，第一条记录的下标是0

        记录数是指从起始记录开始向后依次取的记录数。

连接查询

1、内连接（交集）

语法：select  字段  from  表1 inner  join  表2  on 表1.字段1=表2.字段2  where  条件

on是连接条件，where是连接后筛选条件。

2、外连接分为左连接和右连接

左连接：查询的结果为两个表匹配到的数据和左表特有的数据，对于右表中不存在的数据使用null进行填充。右连接同理。

左连接语法：主表  left join 从表 on 连接条件

右连接语法：从表 right join 主表 on 连接条件

3、自连接：使用自连接查询，只需要一个表，可以加快查询速度，减少数据表占用空间。

例如：通过里查询广东省的所有城市并返回

语法：

4、子查询

子查询是 把一个查询的结果当成另一个查询的条件

（1）标量子查询：子查询返回的结果是一个数据（一行一列）

（2）列子查询：返回的结果是一列（一列多行）

（3）行子查询：返回的结果是一行（一行多列）

外键（foreign key）

一个表的主键A，在另一个表B中出现，这样A是表B的一个外键。

外键的作用：可以限制无效数据插入到表中。

插入外键：alter  table  goods add foreign key(cate_id)  references goods_cates(id);

删除外键：第一步：获取外键名称：show create table goods;

        第二步：删除外键：alter  table goods drop foreign key goods_ibfk_1;

视图

视图就是一个能把复杂的SQL语句的功能封装起来的一个虚表。所以我们在创建视图的时候，主要的工作就落在创建这条SQL查询语句上。

视图是对若干张基本表的引用，一张虚表，不存储具体的数据（基本表数据发生了改变，视图也会跟着改变）

优点：方便操作，主要是查询操作，减少复杂的SQL语句，增强可读性，复用性。

语法：

创建视图：create view 视图名称  as selece 语句;

查看视图：show tables;

使用视图：select * from v_goods_info;

删除视图：drop view 视图名称;

事务（Transaction）

事务是指作为一个基本工作单元执行的一系列SQL语句的操作，要么完全地执行，要么完全地都不执行，不能执行一半。

事务的四大特性（ACID）：原子性，一致性，隔离性，持久性。

事务的使用：

（1）开启事务，start transaction

（2）提交事务，将缓存中的数据变更维护到物理表中  commit;

（3）回滚事务，放弃缓存中变更的数据，表示事务执行失败，应该回到开始事务前的状态。rollback;

索引

索引是一种特殊的文件，它们包含着对数据表里所有记录的位置信息。

索引使用：

（1）查看表中索引：show index from 表名;

（2）创建索引：alter table 表名 add index 索引名【可选】（字段名,...）;

（3）删除索引：drop index 索引名称 on 表名;

数据库三范式

范式的划分：数据冗余是指数据之间的重复，也可以说同一数据存储在不同数据文件中的现象。根据数据库冗余的大小，越高的范式数据库冗余越小。

 一般遵循前三个范式就可以了。

第一范式：强调的是字段的原子性，即一个字段不能再分成其他几个字段。

第二范式：在满足第一范式的基础上，另外还有两个要求：一是表必须有主键（注意：主键可以由多个字段构成），二是非主键字段必须完全依赖于主键，而不是只依赖于主键的一部分。

这里主键是由OrderID和ProductID共同组成，而非关键字段（比如ProductName）并不是完全依赖于主键，而是依赖于ProductID，所以不满足第二范式。

要修改：

第三范式：在满足第二范式的基础上，另外非主键字段必须直接依赖于主键，不能存在传递依赖。即不能存在：非主键字段A依赖于非主键字段B，非主键字段B依赖于主键的情况。

PyMysql模块

安装：pip install pymysql

使用：（1）导入pymysql包（2）创建连接对象（3）获取游标对象

        （4）pymysql完成数据的增删改查  （5）关闭游标和连接

（2）创建连接对象：

 （3）获取游标对象：

 （4）增删改查：先写sql语句（查询语句：sql = "select * from 表名"）,执行sql语句：cursor.execute(sql)

增加数据：sql = "insert into students(name)  values('老王')"

（5）先关闭游标，再关闭连接

SQL语句参数化

SQL注入：用户提交了带有恶意的数据与SQL语句进行字符串方式的拼接，从而影响了SQL语句的语义，最终产生数据泄露的现象。

SQL语句参数化：

（1）SQL语言中的参数使用％ｓ来占位，此处不是python中的字符串格式化操作

（2）将SQL语句中%s展占位所需要的参数存在一个列表中，把参数列表传递给execute方法中第二个参数。

装饰器

装饰器就是闭包，用来给函数增加功能。

 #装饰器装饰带有返回值的函数
 
 #定义装饰器
def logging(fn):#装饰器中 fn = sum_num
    def inner(a,b):
         fn(a,b)
         print("装饰器增加功能")
    return inner
 
#使用装饰器装饰函数
@logging
def sum_num(a,b):
    result = a + b    
    print(result)
 
sum_num(1,2)

 #装饰器装饰带有不定长参数的函数
 
 #定义装饰器
def logging(fn):#装饰器中 fn = sum_num
    def inner(*args, **kwargs):
         fn(*args, **kwargs)
         print("装饰器增加功能")
    return inner
 
#使用装饰器装饰函数
@logging
def sum_num(*args, **kwargs):
    print(args,kwargs)
 
sum_num(1,2,age = "18")

 #多个装饰器装饰一个函数
 
 #定义装饰器1
def check1(fn1):
    def inner1():
        print("验证1")
        fn1()
    return inner1
 #定义装饰器1
def check2(fn2):
    def inner2():
        print("验证2")
        fn2()
    return inner2
 
#使用装饰器装饰函数
@check1
@check2
def comment():
    print("发表评论")
 
comment()

结果：

所以说，当多个装饰器装饰函数的时候，距离越近的装饰器，越先装饰函数。 

类装饰器：

1、__call__方法：

一个类里面一旦实现了__call__方法，那么这个类创建的对象就是一个可调用的对象，可以像调用函数一样进行调用。

#定义一个类，实现__call__方法：
class Check(object):
    def __call__(self, *args, **kwds):
        print("我是call方法")
 
c = Check()
#此时c就相当于一个函数，会返回__call__中的内容
c()

2、类装饰器

#定义类装饰器
class Check(object):
    def __init__(self,fn):
        self.__fn = fn
    def __call__(self, *args, **kwds):
        print("我是call方法")
        self.__fn()   #comment()
 
#调用类装饰器
@Check  # comment = Check(comment)
def comment():
    print("发表评论")
 
comment()

 property属性

property 属性就是负责把类中的一个方法当作属性进行使用，这样做可以简化代码使用

#正常情况下，访问类中的私有属性
class Person(object):
    def __init__(self) -> None:
        self.__age = 0
 
    def age(self):
        return self.__age
 
p = Person()
age = p.age()
print(age)

使用property装饰器之后：

#正常情况下，访问类中的私有属性
class Person(object):
    def __init__(self) -> None:
        self.__age = 0
    
    #property
    def age(self):
        return self.__age
 
p = Person()
print(p.age)

class Person(object):
    def __init__(self) -> None:
        self.__age = 0
    
    #装饰器方式的property，把age方法当作属性使用，表示当获取属性时会执行下面修饰的方法
    @property #获取属性
    #@property表示把方法当作属性使用，表示当获取属性时会执行下面的修饰的方法
    def age(self):
        return self.__age
    
    #把age方法当作属性使用，表示当设置属性时会执行下面修饰方法
    @age.setter #修改属性
    #@age.setter表示把方法当作属性使用，表示当设置属性时会执行下面修饰的方法
    #装饰器方式的property属性修饰方法名一定要一样。
    def age(self,new_age):
        if new_age >= 150:
            print("成精了")
            self.__age = new_age
        else:
            self.__age = new_age
 
p = Person()
print(p.age)
#修改属性
p.age = 170
print(p.age)

 类属性方式的property属性

class Person(object):
    def __init__(self) -> None:
        self.__age = 0
    
    def get_age(self):
    #当获取age属性的时候会执行该方法
        return self.__age 
 
    def set_age(self,new_age):
        if new_age >= 150:
            print("成精了")
            self.__age = new_age
        else:
            self.__age = new_age
 
    #类属性方式的property属性 
    age = property(get_age,set_age)
 
p = Person()
print(p.age)
#设置属性
p.age = 100
print(p.age)

with语句

with语句的作用：既简单又安全，可以自动调用关闭文件操作，即使出现异常也会自动调用关闭文件操作。

with背后是由上下文管理器作支撑的。

一个类只要实现了__enter__()和__exit__()这两个方法，通过该类创建的对象我们就称之为上下文管理器。

生成器

生成器的作用：根据程序设计者制定的规则循环生成数据，当条件不成立时则生成数据结束。数据不是一次性全部生成出来，而是使用一个，再生成一个，可以节约大量的内存。

例如：我们如果在列表里面生成100个数据，这100个数据可能我们就用到10，那么其余的90个就浪费了。而生成器生成100个数据，不是立马就生成100个数据，如果我们只需要10个数据，用到10个就生成10个。

创建生成器：

data = (i*2 for  i  in  range(5))

next(data)  依次生成0，1，2，调用一次next函数生成一次

若要全部生成：for i in data print(i)

yield关键字：

for i in range(10):

        print("开始生成")

        yield i

        print("完成一次")

 深拷贝和浅拷贝

浅拷贝：copy函数，只对可变类型的第一层对象进行拷贝，对拷贝的对象开辟新的内存空间进行存储，不会拷贝对象内部的子对象。 

可变的浅拷贝说明：

 不可变的浅拷贝说明：不可变类型进行浅拷贝不会给拷贝对象开辟新的内存空间，而只是拷贝了这个对象的引用。

深拷贝：用deepcopy函数，只要发现拷贝对象由可变类型就会对该对象到最后一个可变类型的每一层对象进行拷贝，对每一层拷贝的对象都会开辟新的内存空间进行存储。

 HTML

 <h1>...</h1>:设置字体大小，h1是最大的字体，h6是最小的字体

<p>....</p> : 段落标签

<div>....</div>:容器标签

<img> : 加载图片

<hr>: 在HTML页面中创建一条水平线

<br> : 可插入一个简单的换行符

<a  href = "www.....">..</a>:定义超链接，用于从一张页面链接到另一张页面。

<ul><li>....</li></ul>:无序列表标签

<ol><li>....</li></ol>:有序列表标签

单标签<meta> 是<head>的辅助标签，常用于定义一些关键字，说明之类的。

<table>标签：表示一个表格

        <tr>标签：表示表格中的一行

                <td>标签：表示表格中的列

                <th>标签：表示表格中的表头

                border:1px solid black:设置边框和颜色

                border-collapse: collapse:设置边框合并

<form>标签，表示表单标签，定义整体表单区域。表单用于搜集不同类型的用户输入的数据，然后可以把用户数据提交到web服务器。一个表单有很多信息组成，比如下图

这些内容有很多其他标签来承载，这些标签称为表单元素标签。

表单元素属性设置：

name属性：设置表单元素的名称，该名称是提交数据时的参数名

value属性：设置表单元素的值，该值时提交数据时参数名所对应的值

表单提交：表单用于搜集不同类型的用户输入的数据，然后可以把用户数据提交到web服务器。

设置表单属性提交数据：

action属性，设置表单数据提交地址

method属性：设置表单提交的方式，一般有“GET”方式和“POST”方式（“GET”方式没有请求体，“POST”方式有请求体），不区分大小写。

CSS

CSS是美化页面的语言。

CSS语法：

选择器{样式规则}   其中样式规则是：属性名1：属性值1；属性名2：属性值2；

选择器是用来选择标签的，选出来以后给标签加样式。例如：

CSS引入方式

1、行内式：直接在标签的style属性中添加CSS样式

可视化，但不可重用

 2、内嵌式（内部样式）：在<head>标签中加入<style>标签，在<style>标签中编写CSS代码。

 同一个页面内可以复用和维护。但多页面之间的重用性不高。

3、外链式：将CSS代码写在一个单独的.CSS文件中，在<head>标签中使用<link>标签直接引入该文件到页面中。

CSS选择器

用来选择标签，选出来之后给标签增加样式。

常见的选择器有：（1）标签选择器（2）类选择器（3）层级选择器(后代选择器)

（4）id选择器（5）组选择器（6）伪类选择器

（1）标签选择器，根据标签选择器来选择标签，以标签开头，此种选择器影响范围大，一般用来做一些通用的设置。

 （2）类选择器，以 . 开头

 （3）层级选择器，根据层级关系选择后代标签，以选择器1选择器2开头

（4）id选择器，以#开头，元素的id名称不能重复，所以id选择器只能对应于页面上一个元素。

 （5）组选择器，以 , 分隔开

（6）伪类选择器，主要是添加特效效果，以  :  分隔开

 CSS属性

 JavaScript（负责网页行为）

JavaScript式运行在浏览器端的脚本语言，是由浏览器解释执行的，简称js，它能够让网页和用户有交互功能，增加良好的用户体验效果。

 JavaScript的使用方式

1、行内式

 2、内嵌式

 3、外链式

JavaScript变量和数据类型

JavaScript是一种弱类型语言，不需要指定变量的类型。Javascript的变量类型由它的值来决定，定义变量需要用关键字‘var’， 一条Javascript语句应以 ' ; '来结尾。

数据类型：

 命名规则：

 

<!DOCTYPE html>
<html>
    <head lang="en">
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width,initial-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>Document</title>
        
        <!--内嵌式写入JavaScript-->
        <script>
            //(1)数字number
            var inum = 10;
            var fnum = 10.1;
            //(2)字符串string
            var sName = "itcast"
            //(3)布尔 boolean
            var bIsTrue = true;
            //(4)未定义 undefined
            var unData;
            //(5)空类型 null
            var nullData = null;
            //(6) object表示对象类型
            var oPerson = {
                name:"itcast",
                age:12
            }
            //获取变量类型typeof
            alert(typeof(inum))
            alert(typeof(fnum))
 
            //获取数据,console.log方便调式javascript用的,可以看到在页面中输出的内容,与alert相比,它能看到结构化的东西,而alert淡出一个对象就是[obujct object],但comsole能看到对象的内容,console不会打断页面的操作
            console.log(oPerson.name)
            console.log(oPerson.age)
        </script>
    </head>
<body>
</body>
</html>

 JavaScript函数

JavaScript函数使用的是function进行定义。

函数调用的时候，后面要加上小括号。

 JavaScript处理标签元素

1、获取标签元素，使用内置对象document的getElementById方法（如果没有获取成功，则返回的是null）来获取页面上设置了id属性的标签元素，获取到的是一个html对象，然后将它赋值给一个变量。

<!DOCTYPE html>
<html>
    <head lang="en">
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width,initial-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>Document</title>
        
        <!--内嵌式写入JavaScript-->
        <script>
            //定义一个函数，方便随时调用
            function fnLoad(){
                //通过内置方法获取对应的id的标签，如果没有获取成功返回null
                var oBtn = document.getElementById("btn")
                alert(oBtn)
            }
 
            //因为按顺序执行，如果不定义函数就会先执行getElementById，但是还没有input，所以就会报错。所以要定义函数。定义函数通过onload事件对函数进行使用。
            //onload事件：页面数据加载完毕后触发，是一个被动事件。
            window.onload = fnLoad;
 
 
            //工作的写法,更加方便一点
            //window.onload = function(){
                //通过内置方法获取对应的id的标签，如果没有获取成功返回null
              //  var oBtn = document.getElementById("btn")
           //     alert(oBtn)
           // }
 
 
        //onclick事件：点击触发，是一个主动的事件。
        </script>
    </head>
<body>
    <input type="button" value="按钮" id="btn" onclick="fnLoad()">
</body>
</html>

 2、操作标签元素

<!DOCTYPE html>
<html>
    <head lang="en">
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width,initial-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>Document</title>
        <!--类样式-->
        <style>
            .mybtn{
                width: 100px;
                height: 100px;
                background: green;
            }
        </style>
        <!--内嵌式写入JavaScript-->
        <script>
            //定义一个函数，方便随时调用
            function fnLoad(){
                //通过内置方法获取对应的id的标签，如果没有获取成功返回null
                var oBtn = document.getElementById("btn")
                // oBtn.value = "username"
                // oBtn.style.background = "red"
                oBtn.className = "mybtn"
            }
        </script>
    </head>
<body>
    <input type="button" value="按钮" id="btn" onclick="fnLoad()">
</body>
</html>

3、读取或设置标签包裹的内容

使用innerHTML可以读取或者设置标签包裹的内容。

<!DOCTYPE html>
<html>
    <head lang="en">
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width,initial-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>Document</title>
        <!--内嵌式写入JavaScript-->
        <script>
            //等待我们的页面数据加载完毕触发onload事件
            window.onload =  function fnLoad(){
                var oDiv = document.getElementById("mydiv")
                oDiv.innerHTML = "你好阳光";
            }
        </script>
    </head>
<body>
    <div id="mydiv">我是一个标签</div>
</body>
</html>

JavaScript数组

  数组的创建：           

 多维数组的创建：

获取数组的长度：alist.length;

添加数据：aList.push(5);    删除最后一个数据：aList.pop();  

根据下标添加和删除元素：

2、字符串拼接

JavaScript的字符串拼接直接使用：“+”。

var  sStr  =  "123"  //这是字符串类型

转化成整型或者浮点型： parseInt(sStr)   或  parseFloat(sStr)

JS定时器

1、设置定时器：setTimeout（）函数

 2、设置定时器：setInterval（）函数

 3、清除定时器：clearTimeout（timeoutID）

清楚setTimeout（）函数，timeID为调用setTimeout函数时所获得的返回值。

4、清楚定时器：clearInterval(timeoutID)

清楚setInterval（）函数，timeID为调用setInterval函数时所获得的返回值。

<!DOCTYPE html>
<html>
    <head lang="en">
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width,initial-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>Document</title>
        <!--内嵌式写入JavaScript-->
        <script>
            function fnShow(name){
                alert(name);
               
            }
           //停止重复定时器的函数
            function fnStop(name){
                clearInterval(tId);
            } 
        
            var tId = setInterval(fnShow,2000,"itcast")
        </script>
    </head>
<body>
    <input type="button" value="停止" onclick=fnStop()">
</body>
</html>

 jQuery

 jQuery是对js的封装，简化了js编程，实现交互效果更简单。

1、jQuery的引入：

入口函数：我们知道使用js获取标签元素，需要页面加载完成以后在获取，我们通过使用onload事件来获取标签元素，而jQuery提供了ready函数来解决问题，保证获取标签元素没有问题，它的速度比原生的我window.onload更快。

入口函数：

 2、jQuery选择器

作用：快速选择标签元素，获取标签，选择规则和CSS选择器一样。

 选择集过滤和转移

选择集过滤就是在选择标签的集合里面过滤自己需要的标签，即可以对不同的标签设置不同的样式。

选择集过滤的操作：

1、has(选择器名称)方法，表示选取包含指定选择器的标签

2、eq(索引)方法，表示选取指定索引的标签

 选择集转移

选择集转移就是以选择的标签为参照，然后获取转移后的标签。

 获取和设置元素内容和属性

1、jquery中的html方法可以获取和设置标签的内容

 给指定元素追加html内容使用：append方法

2、获取和设置元素属性

获取和修改标签样式：使用css方法可以给标签设置样式属性

获取和修改标签属性：设置标签的其他属性可以使用prop方法

获取和设置元素的value属性：通过val方法来完成，更加简单和方便。

jQuery事件 及事件代理

1、事件就是用户做出某种动作，对应生成特定的结果。

常见事件：

<!DOCTYPE html>
<html>
    <head lang="en">
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width,initial-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>Document</title>
        <!--内嵌式写入JavaScript-->
        <!-- 导入jQuery文件 -->
        <script src="jquery.js"></script>
        <script>
            //ready() DOM加载完成
            //$(document).ready(function(){
            //     alert("1");
            // });
 
            
            $(function(){
                //获取标签对象
                var $mytext = $("#text1");
                var $mybtn = $("#btn1")
                //click()鼠标单击
                $mybtn.click(function(){
                    alert("incast");
                });
 
                //focus() 元素获得焦点 
                $mytext.focus(function(){
                    //原生js写法
                    this.style.background = "red";
                    //jQury写法
                    $(this).css({"background":"red"});
                });
                //blur（） 失去焦点
                $mytext.blur(function(){
                    //原生js写法
                    this.style.background = "white";
                    //jQury写法
                    $(this).css({"background":"white"});
                });
 
                //mouseover()鼠标进入（进入子元素也触发）
                
            });
        </script>
    </head>
<body>
    <input type="text" id="text1">
    <input type="button" value="按钮" id="btn1">
</body>
</html>

2、事件代理

事件代理就是利用事件冒泡的原理（事件冒泡就是事件会向它的父级一级一级传递），把事件加到父级上通过判断事件来源，执行相应的子元素的操作。

事件代理首先可以极大减少事件绑定次数吗，提高性能，其次可以让新加入的子元素也可以有相同的操作。

使用：

delegate(childSelector, event, function)

childSelector:子元素的选择器

event:事件名称

function:当事件触发执行的函数

JavaScript对象 

除了字符串，数值，数组，函数等，还可以允许自定义对象，对象可以拥有属性和方法。

创建自定义JavaScript对象的两种方式：

1、object类创建对象

 2、对象字面量创建对象

 ajax、

浏览器一次完整的请求之后，会接收到html,css,js，图片等大量的数据。

例如查询天气，对于浏览器来说唯一需要改变的数据只有天气数据，也就是局部数据的更新

ajax是一个前后台配合的技术，可以让Javascript发送异步的http请求，与后台通信进行数据的获取，ajax最大的优点式实现局部刷新，ajax可以发送http请求，当获取到后台数据的时候更新页面显示数据实现局部刷新，当前端页面想和后端服务器进行数据交互的时候就可以使用ajax了。

jQuery将它封装成了一个方法$.ajax()中

 

web框架

web框架简介

静态web服务器式返回静态资源，web框架专门负责处理用户的动态资源请求。