zj-teach/pages/stuList/stuList.js

// pages/stuList/stuList.js
let searchLists = [] //搜索条件列表
searchLists.length = 7
Page({

    /**
     * 页面的初始数据
     */
    data: {
        toSearch: false, //打开/关闭筛选区
        courseChosedIndex: '', //选中科目的索引
        showCourse: false, //科目选项区是否显示
        courseDetailChosed: '', //课程详情筛选条件
        courseDetailIndex: null, //选中课程详情的索引
        showCourseDetail: false, //课程详情选项区是否显示
        teachPositionChosed: '', //需求辅导方式
        showTeachPosition: false, //需求辅导方式选项区是否显示
        stuSexChosed: '', //学生性别
        showSexList: false, //学生性别选项区是否显示
        teachTypeChosed: '', //教员类型
        showTeachType: false, //教员类型选项区是否显示
        teachEduChosed: '', //老师学历的筛选条件
        showTeachEdu: false, //老师学历选项区是否显示
        teachSexChosed: '', //老师性别的筛选条件
        showTeachSex: false, //老师性别选项区是否显示
        teachImgChosed: '', //老师照片的筛选条件
        showTeachImg: false, //老师照片选项区是否显示
        list: [], //筛选后的列表
        isSearch: false, //是否点击搜索
        // 筛选条件
        // 1、课程类别
        courseList: ['小学', '初中', '高中', '大学', '音乐', '舞蹈', '语言', '体育', '美术', '书法', '少儿编程', '计算机', '其他'],
        // 课程详情
        courseDetail: [
            ['小学1-5数学', '小学1-5英语', '小学1-5语文', '小学6数学', '小学6英语', '小学6语文', '小学奥数'],
            ['初一初二语文', '初一初二数学', '初一初二英语', '初一初二物理', '初一初二化学', '初三语文', '初三数学', '初三英语', '初三物理', '初三化学', '初中历史', '初中地理', '初中奥数', '初中生物', '初中预备班', '初中科学', '初中政治'],
            ['高一高二语文', '高一高二数学', '高一高二英语', '高一高二物理', '高一高二化学', '高三语文', '高三数学', '高三英语', '高三物理', '高三化学', '高中历史', '高中地理', '高中政治', '高中生物', '信息科技', 'SAT'],
            ['托福', '雅思', '高等数学', '微观经济学', 'MBA', '成人高考', '国学', '自学考试', '专升本', '考博面试辅导', '考博专业课', '考博英语', '英语四级', '英语六级', '论文指导', '考研专业课', '考研政治', '考研数学', '考研英语', '英语专业四级', '英语专业八级', '课程辅导'],
            ['小提琴', '钢琴', '电子琴', '长笛', '琵琶', '手风琴', '古筝', '练耳歌唱', '大号', '声乐', '萨克斯', '单簧管', '吉他', '小号', '古琴', '二胡', '大提琴', '打击乐', '圆号', '中提琴', '竹笛', '架子鼓', '扬琴', '巴松'],
            ['民族舞', '爵士舞', '拉丁舞', '芭蕾舞', '街舞', '现代舞', '踢踏舞'],
            ['本地方言', '日语', '英语口语', '新概念英语', '牛津英语', '西班牙语', '德语', '商务英语', '法语', '韩语', '意大利语', '汉语', '阿拉伯语', 'SBS英语', '俄语', '葡萄牙语'],
            ['羽毛球', '跆拳道', '游泳', '乒乓球', '网球', '中国象棋', '国际象棋', '围棋', '篮球', '空手道'],
            ['卡通画', '中国画', '素描', '油画', '水彩', '漫画'],
            ['硬笔', '毛笔', '篆刻'],
            ['Scratch', 'Python', 'C++', 'microbit'],
            ['应用能力初级', '应用能力中级', '基本操作'],
            ['学习习惯', '口才', '心理辅导', '记忆力', '注意力']
        ],
        // 2、辅导方式
        teachPositions: ['不限', '老师上门', '学员上门', '线上辅导', '老师住家', '学员住家'],
        // 3、性别列表
        sexList: ['不限', '男', '女'],
        // 4、教员类型
        teachType: ['不限', '专职老师', '在校大学生'],
        // 5、教员学历
        educationList: ['不限', '博士毕业', '博士在读', '硕士毕业', '硕士在读', '本科毕业', '本科在读', '专科毕业', '专科在读'],
        // 6、老师照片选项
        teachImgOptions: ['不限', '有照片'],
        // 模拟后台读取的学生列表信息
        stuLists: [
            [{
                    id: '20220811'
                },
                {
                    name: '孙悟空'
                },
                {
                    phone: '13400000000'
                },
                {
                    weChatNum: '13400000000'
                },
                {
                    courseNeed: '小学'
                },
                {
                    courseDetail: '小学1-5语文'
                },
                {
                    teachPosition: '不限'
                },
                {
                    stuSex: '男'
                },
                {
                    salary: '200'
                },
                {
                    schoolTime: '周六晚上'
                },
                {
                    except: '全力以赴备战小升初'
                },
                {
                    teachId: '在校大学生'
                },
                {
                    teachEdu: '本科在读'
                },
                {
                    teachSex: '女'
                },
                {
                    teachImg: '不限'
                },
                {
                    otherNeed: '无'
                }
            ],
            [{
                    id: '20220821'
                },
                {
                    name: '孙悟空'
                },
                {
                    phone: '13400000000'
                },
                {
                    weChatNum: '13400000000'
                },
                {
                    courseNeed: '初中'
                },
                {
                    courseDetail: '初一初二语文'
                },
                {
                    teachPosition: '老师上门'
                },
                {
                    stuSex: '男'
                },
                {
                    salary: '200'
                },
                {
                    schoolTime: '周六晚上'
                },
                {
                    except: '考上重点初中'
                },
                {
                    teachId: '在校大学生'
                },
                {
                    teachEdu: '本科在读'
                },
                {
                    teachSex: '男'
                },
                {
                    teachImg: '有照片'
                },
                {
                    otherNeed: '无'
                }
            ],
            [{
                    id: '20220811'
                },
                {
                    name: '孙悟空'
                },
                {
                    phone: '13400000000'
                },
                {
                    weChatNum: '13400000000'
                },
                {
                    courseNeed: '高中'
                },
                {
                    courseDetail: '高一高二物理'
                },
                {
                    teachPosition: '学员住家'
                },
                {
                    stuSex: '女'
                },
                {
                    salary: '200'
                },
                {
                    schoolTime: '周日晚上'
                },
                {
                    except: '好好学习，天天向上，考个重点大学'
                },
                {
                    teachId: '专职老师'
                },
                {
                    teachEdu: '本科毕业'
                },
                {
                    teachSex: '不限'
                },
                {
                    teachImg: '不限'
                },
                {
                    otherNeed: '无'
                }
            ],
            [{
                    id: '20220811'
                },
                {
                    name: '孙悟空'
                },
                {
                    phone: '13400000000'
                },
                {
                    weChatNum: '13400000000'
                },
                {
                    courseNeed: '小学'
                },
                {
                    courseDetail: '小学1-5语文'
                },
                {
                    teachPosition: '学员住家'
                },
                {
                    stuSex: '女'
                },
                {
                    salary: '200'
                },
                {
                    schoolTime: '周六晚上'
                },
                {
                    except: '考个第一'
                },
                {
                    teachId: '在校大学生'
                },
                {
                    teachEdu: '本科在读'
                },
                {
                    teachSex: '女'
                },
                {
                    teachImg: '有照片'
                },
                {
                    otherNeed: '无'
                }
            ],
            [{
                    id: '20220821'
                },
                {
                    name: '孙悟空'
                },
                {
                    phone: '13400000000'
                },
                {
                    weChatNum: '13400000000'
                },
                {
                    courseNeed: '初中'
                },
                {
                    courseDetail: '初一初二语文'
                },
                {
                    teachPosition: '老师住家'
                },
                {
                    stuSex: '男'
                },
                {
                    salary: '200'
                },
                {
                    schoolTime: '周六晚上'
                },
                {
                    except: '考个好学校'
                },
                {
                    teachId: '在校大学生'
                },
                {
                    teachEdu: '硕士在读'
                },
                {
                    teachSex: '男'
                },
                {
                    teachImg: '不限'
                },
                {
                    otherNeed: '无'
                }
            ],
            [{
                    id: '20220811'
                },
                {
                    name: '孙悟空'
                },
                {
                    phone: '13400000000'
                },
                {
                    weChatNum: '13400000000'
                },
                {
                    courseNeed: '高中'
                },
                {
                    courseDetail: '高一高二物理'
                },
                {
                    teachPosition: '线上辅导'
                },
                {
                    stuSex: '女'
                },
                {
                    salary: '200'
                },
                {
                    schoolTime: '周日晚上'
                },
                {
                    except: '好好学习'
                },
                {
                    teachId: '专职老师'
                },
                {
                    teachEdu: '硕士毕业'
                },
                {
                    teachSex: '不限'
                },
                {
                    teachImg: '不限'
                },
                {
                    otherNeed: '无'
                }
            ],
            [{
                    id: '20220811'
                },
                {
                    name: '孙悟空'
                },
                {
                    phone: '13400000000'
                },
                {
                    weChatNum: '13400000000'
                },
                {
                    courseNeed: '小学'
                },
                {
                    courseDetail: '小学1-5语文'
                },
                {
                    teachPosition: '老师上门'
                },
                {
                    stuSex: '男'
                },
                {
                    salary: '200'
                },
                {
                    schoolTime: '周六晚上'
                },
                {
                    except: '考个好初中'
                },
                {
                    teachId: '专职老师'
                },
                {
                    teachEdu: '专科毕业'
                },
                {
                    teachSex: '女'
                },
                {
                    teachImg: '不限'
                },
                {
                    otherNeed: '无'
                }
            ],
            [{
                    id: '20220821'
                },
                {
                    name: '白骨精'
                },
                {
                    phone: '13400000000'
                },
                {
                    weChatNum: '13400000000'
                },
                {
                    courseNeed: '初中'
                },
                {
                    courseDetail: '初一初二语文'
                },
                {
                    teachPosition: '老师上门'
                },
                {
                    stuSex: '女'
                },
                {
                    salary: '200'
                },
                {
                    schoolTime: '周六晚上'
                },
                {
                    except: '顺利升学'
                },
                {
                    teachId: '专职老师'
                },
                {
                    teachEdu: '本科毕业'
                },
                {
                    teachSex: '男'
                },
                {
                    teachImg: '不限'
                },
                {
                    otherNeed: '无'
                }
            ],
            [{
                    id: '20220811'
                },
                {
                    name: '孙悟空'
                },
                {
                    phone: '13400000000'
                },
                {
                    weChatNum: '13400000000'
                },
                {
                    courseNeed: '高中'
                },
                {
                    courseDetail: '高一高二物理'
                },
                {
                    teachPosition: '不限'
                },
                {
                    stuSex: '男'
                },
                {
                    salary: '200'
                },
                {
                    schoolTime: '周日晚上'
                },
                {
                    except: '补课'
                },
                {
                    teachId: '在校大学生'
                },
                {
                    teachEdu: '硕士在读'
                },
                {
                    teachSex: '不限'
                },
                {
                    teachImg: '不限'
                },
                {
                    otherNeed: '无'
                }
            ],
        ]
    },

    /**
     * 生命周期函数--监听页面加载
     */
    onLoad(options) {

    },

    //跳转到学生详情页
    toStuDetail() {
        wx.navigateTo({
            url: '/pages/stuDetail/stuDetail',
        })
    },

    // 找学员按钮的点击事件
    toOpenSearch() {
        let toSearch = this.data.toSearch
        this.setData({
            toSearch: !toSearch
        })
        // 判断打开找学员的筛选区的条件是否为false，如果是，则关闭所有选项的筛选区
        if (!this.data.toSearch) {
            this.setData({
                showCourse: false,
                showCourseDetail: false,
                showTeachPosition: false,
                showSexList: false,
                showTeachType: false,
                showTeachEdu: false,
                showTeachSex: false,
                showTeachImg: false
            })
        }
    },

    // 科目筛选项
    // 打开科目选项区，关闭其他选项区
    chooseCourse() {
        let showCourse = this.data.showCourse
        this.setData({
            showCourse: !showCourse,
            showCourseDetail: false,
            showTeachPosition: false,
            showSexList: false,
            showTeachType: false,
            showTeachEdu: false,
            showTeachSex: false,
            showTeachImg: false
        })
    },
    // 选择科目大类
    chosedCourse(e) {
        // console.log(e.currentTarget.dataset.index);
        let courseChosedIndex = e.currentTarget.dataset.index
        this.setData({
            courseChosedIndex,
            showCourseDetail: true
        })
        // console.log(this.data.courseChosedIndex);
    },
    // 选择课程详情
    chosedCourseDetail(e) {
        // console.log(e.currentTarget.dataset.index);
        let index = e.currentTarget.dataset.index
        let courseDetail = this.data.courseDetail
        let courseChosedIndex = this.data.courseChosedIndex
        this.setData({
            courseDetailChosed: courseDetail[courseChosedIndex][index],
            showCourseDetail: false,
            showCourse: false,
            courseDetailIndex: e.currentTarget.dataset.index,
        })
        searchLists[0] = this.data.courseDetailChosed
        // console.log(this.data.courseDetailChosed);
        // console.log(this.data.courseDetailIndex);
    },
    // 需求课程取消图标的功能
    cancelChooseCourse() {
        searchLists[0] = ''
        this.setData({
            courseDetailChosed: '',
            showCourse: false,
            showCourseDetail: false,
            showTeachPosition: false,
            showSexList: false,
            showTeachType: false,
            showTeachEdu: false,
            showTeachSex: false,
            showTeachImg: false
        })
    },

    // 辅导方式
    // 打开辅导方式筛选区，关闭其他选项筛选区
    chooseTeachPosition() {
        let showTeachPosition = this.data.showTeachPosition
        this.setData({
            showCourse: false,
            showCourseDetail: false,
            showTeachPosition: !showTeachPosition,
            showSexList: false,
            showTeachType: false,
            showTeachEdu: false,
            showTeachSex: false,
            showTeachImg: false
        })
    },
    // 选择辅导方式
    toChosedTeachPosition(e) {
        // console.log(e);
        let index = e.currentTarget.dataset.index
        let teachPositionChosed = this.data.teachPositionChosed
        let teachPositions = this.data.teachPositions
        for (let i = 0; i < teachPositions.length; i++) {
            if (i == index) {
                teachPositionChosed = teachPositions[i]
            }
        }
        this.setData({
            teachPositionChosed,
            showTeachPosition: false
        })
        searchLists[1] = this.data.teachPositionChosed
    },
    // 辅导方式取消图标的功能
    cancelChooseTeachPosition() {
        searchLists[1] = ''
        this.setData({
            teachPositionChosed: '',
            showCourse: false,
            showCourseDetail: false,
            showTeachPosition: false,
            showSexList: false,
            showTeachType: false,
            showTeachEdu: false,
            showTeachSex: false,
            showTeachImg: false
        })
    },

    // 选择学生性别筛选项
    // 打开学生性别选项区，关闭其他选项区
    chooseStuSex() {
        // console.log(searchLists);
        let showSexList = this.data.showSexList
        this.setData({
            showCourse: false,
            showCourseDetail: false,
            showTeachPosition: false,
            showSexList: !showSexList,
            showTeachType: false,
            showTeachEdu: false,
            showTeachSex: false,
            showTeachImg: false
        })
    },
    // 选择学生性别
    toChosedStuSex(e) {
        let index = e.currentTarget.dataset.index
        let stuSexChosed = this.data.stuSexChosed
        let sexList = this.data.sexList
        for (let i = 0; i < sexList.length; i++) {
            if (i == index) {
                stuSexChosed = sexList[i]
            }
        }
        this.setData({
            stuSexChosed,
            showSexList: false
        })
        searchLists[2] = this.data.stuSexChosed
    },
    // 学生性别取消图标的功能
    cancleChooseStuSex() {
        searchLists[2] = ''
        this.setData({
            stuSexChosed: '',
            showCourse: false,
            showCourseDetail: false,
            showTeachPosition: false,
            showSexList: false,
            showTeachType: false,
            showTeachEdu: false,
            showTeachSex: false,
            showTeachImg: false
        })
    },

    // 教员类型筛选项
    // 打开老师身份选项区，关闭其他选项区
    chooseTeachType() {
        let showTeachType = this.data.showTeachType
        this.setData({
            showCourse: false,
            showCourseDetail: false,
            showTeachPosition: false,
            showSexList: false,
            showTeachType: !showTeachType,
            showTeachEdu: false,
            showTeachSex: false,
            showTeachImg: false
        })
    },

    // 选择教员类型
    toChosedTeachType(e) {
        // console.log(e);
        let index = e.currentTarget.dataset.index
        let teachTypeChosed = this.data.teachTypeChosed
        let teachType = this.data.teachType
        for (let i = 0; i < teachType.length; i++) {
            if (i == index) {
                teachTypeChosed = teachType[i]
            }
        }
        this.setData({
            teachTypeChosed,
            showTeachType: false
        })
        searchLists[3] = this.data.teachTypeChosed
    },
    // 教员类型取消图标的功能
    cancelChooseTeachType() {
        searchLists[3] = ''
        this.setData({
            teachTypeChosed: '',
            showCourse: false,
            showCourseDetail: false,
            showTeachPosition: false,
            showSexList: false,
            showTeachType: false,
            showTeachEdu: false,
            showTeachSex: false,
            showTeachImg: false
        })
    },

    // 老师学历筛选项
    // 打开老师学历选项区，关闭其他选项区
    chooseTeachEdu() {
        let showTeachEdu = this.data.showTeachEdu
        this.setData({
            showCourse: false,
            showCourseDetail: false,
            showTeachPosition: false,
            showSexList: false,
            showTeachType: false,
            showTeachEdu: !showTeachEdu,
            showTeachSex: false,
            showTeachImg: false
        })
    },
    // 选择老师学历
    toChosedTeachEdu(e) {
        let index = e.currentTarget.dataset.index
        let teachEduChosed = this.data.teachEduChosed
        let educationList = this.data.educationList
        for (let i = 0; i < educationList.length; i++) {
            if (i == index) {
                teachEduChosed = educationList[i]
            }
        }
        this.setData({
            teachEduChosed,
            showTeachEdu: false
        })
        searchLists[4] = this.data.teachEduChosed
    },
    // 教员学历取消图标的功能
    cancelChooseTeachEdu() {
        searchLists[4] = ''
        this.setData({
            teachEduChosed: '',
            showCourse: false,
            showCourseDetail: false,
            showTeachPosition: false,
            showSexList: false,
            showTeachType: false,
            showTeachEdu: false,
            showTeachSex: false,
            showTeachImg: false
        })
    },

    // 选择老师性别筛选项
    // 打开老师性别选项区，关闭其他选项区
    chooseTeachSex() {
        let showTeachSex = this.data.showTeachSex
        this.setData({
            showCourse: false,
            showCourseDetail: false,
            showTeachPosition: false,
            showSexList: false,
            showTeachType: false,
            showTeachEdu: false,
            showTeachSex: !showTeachSex,
            showTeachImg: false
        })
    },
    // 选择老师性别
    toChosedTeachSex(e) {
        let index = e.currentTarget.dataset.index
        let teachSexChosed = this.data.teachSexChosed
        let sexList = this.data.sexList
        for (let i = 0; i < sexList.length; i++) {
            if (i == index) {
                teachSexChosed = sexList[i]
            }
        }
        this.setData({
            teachSexChosed,
            showTeachSex: false
        })
        searchLists[5] = this.data.teachSexChosed
    },
    // 老师性别取消图标的功能
    cancelChooseTeachSex() {
        searchLists[5] = ''
        this.setData({
            teachSexChosed: '',
            showCourse: false,
            showCourseDetail: false,
            showTeachPosition: false,
            showSexList: false,
            showTeachType: false,
            showTeachEdu: false,
            showTeachSex: false,
            showTeachImg: false
        })
    },

    // 老师照片筛选项
    // 打开老师照片选项区，关闭其他选项区
    chooseTeachImg() {
        let showTeachImg = this.data.showTeachImg
        this.setData({
            showCourse: false,
            showCourseDetail: false,
            showTeachPosition: false,
            showSexList: false,
            showTeachType: false,
            showTeachEdu: false,
            showTeachSex: false,
            showTeachImg: !showTeachImg
        })
    },

    // 选择老师照片筛选条件
    toChosedTeachImg(e) {
        let index = e.currentTarget.dataset.index
        let teachImgChosed = this.data.teachImgChosed
        let teachImgOptions = this.data.teachImgOptions
        for (let i = 0; i < teachImgOptions.length; i++) {
            if (i == index) {
                teachImgChosed = teachImgOptions[i]
            }
        }
        this.setData({
            teachImgChosed,
            showTeachImg: false
        })
        searchLists[6] = this.data.teachImgChosed
    },
    // 老师照片取消图标的功能
    cancelChooseTeachImg() {
        searchLists[6] = ''
        this.setData({
            teachImgChosed: '',
            showCourse: false,
            showCourseDetail: false,
            showTeachPosition: false,
            showSexList: false,
            showTeachType: false,
            showTeachEdu: false,
            showTeachSex: false,
            showTeachImg: false
        })
    },

    // 搜索按钮功能
    handleSearch() {
        // 点击搜索按钮后，将筛选选项区全部置为false（关闭筛选选项区）
        this.setData({
            showCourse: false,
            showCourseDetail: false,
            showTeachPosition: false,
            showSexList: false,
            showTeachType: false,
            showTeachEdu: false,
            showTeachSex: false,
            showTeachImg: false
        })
        // console.log(searchLists[0]);
        // 判断搜索条件的数组是否为空（即是否选择了搜索条件）
        if (!searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3] && !searchLists[4] && !searchLists[5] && !searchLists[6]) {
            this.setData({
                isSearch: false
            })
            wx.showToast({
                title: '您还没选择搜索条件',
                icon: 'none'
            })
            return
        }
        // 当搜索条件数组不为空时，点击搜索按钮后，重新将筛选后的数组设置为空数组，并将是否点击搜索的条件置为true
        this.setData({
            list: [],
            isSearch: true
        })
        let stuLists = this.data.stuLists
        let list = this.data.list
        // 当第一个筛选值存在时,判断第一个筛选值是否符合要求
        if (searchLists[0]) {
            for (let i = 0; i < stuLists.length; i++) {
                for (let j = 0; j < stuLists[i].length; j++) {
                    // console.log(stuLists[i][j].courseDetail);
                    // 判断学生列表中是否有符合第一项筛选条件的信息
                    if (searchLists[0] == stuLists[i][j].courseDetail) {
                        // console.log('ok');
                        // 将满足条件的学生信息添加进新数组
                        list.push(stuLists[i])
                        this.setData({
                            list
                        })
                    }
                }
            }
            // console.log('list第一个：',list);
            if (!list.length) {
                return
            }
        }
        // console.log('list：',list);
        // 当第二个筛选值不为空时,判断第二个筛选值是否符合要求
        if (searchLists[1]) {
            let flag = false
            let newList = []
            let list = this.data.list
            // console.log(list);
            // 当第一个筛选值存在时
            if (searchLists[0]) {
                /* 
                    当第一个筛选项存在时，设置局部变量flag初始值为false，用来判断第二个筛选项在筛选后
                    的数组中是否能找到符合条件的信息，如果能找到，则将flag的值改为true
                */
                // console.log(list);
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        // 判断满足第一个筛选条件的新数组中是否有符合第二个筛选条件的信息
                        if (searchLists[1] == list[i][j].teachPosition) {
                            // 将满足条件的学生信息添加进新数组
                            // console.log('ok');
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            // 如果有满足第二个筛选条件的信息，则将flag的值改为true
                            flag = true
                        }
                    }
                }
                // console.log('flag:',flag);
                // 如果在满足第一个筛选条件的数组中，没有满足第二个筛选条件的信息，则将筛选后的数组置为空数组
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                // console.log(this.data.list);
                // console.log(list);
            }
            // 当其他筛选值都为空时，则在学员数组中查找是否有符合条件的信息
            else if (!searchLists[0]) {
                for (let i = 0; i < stuLists.length; i++) {
                    for (let j = 0; j < stuLists[i].length; j++) {
                        // 判断学生数组中是否有符合第二个筛选条件的信息
                        if (searchLists[1] == stuLists[i][j].teachPosition) {
                            // 将满足条件的学生信息添加进新数组
                            list.push(stuLists[i])
                            this.setData({
                                list
                            })
                        }
                    }
                }
                // console.log(this.data.list);
                // console.log(list);
                if (!list.length) {
                    return
                }
            }
        }
        // 当第三个筛选项不为空时，判断第三个筛选值是否符合要求
        if (searchLists[2]) {
            // 当第三个筛选项不为空时，判断第一个或者第二个筛选条件是否存在
            let flag = false
            let newList = []
            let list = this.data.list
            // 当第一个和第二个筛选值同时存在时，在筛选后的数组里查找是否有符合第三个筛选条件的信息
            if (searchLists[0] && searchLists[1]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[2] == list[i][j].stuSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个筛选值存在，第二个筛选值不存在时
            else if (searchLists[0] && !searchLists[1]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[2] == list[i][j].stuSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个筛选值不存在，第二个筛选值存在时
            else if (!searchLists[0] && searchLists[1]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[2] == list[i][j].stuSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第二个筛选值都为空时，则在学员数组中查找是否有符合条件的信息
            else if (!searchLists[0] && !searchLists[1]) {
                let list = this.data.list
                for (let i = 0; i < stuLists.length; i++) {
                    for (let j = 0; j < stuLists[i].length; j++) {
                        // 判断学生数组中是否有符合第二个筛选条件的信息
                        if (searchLists[2] == stuLists[i][j].stuSex) {
                            // 将满足条件的学生信息添加进新数组
                            list.push(stuLists[i])
                            this.setData({
                                list
                            })
                        }
                    }
                }
                if (!list.length) {
                    return
                }
            }
        }
        // 当第四个筛选项不为空时，判断第四个筛选值是否符合要求
        if (searchLists[3]) {
            let flag = false
            let newList = []
            let list = this.data.list
            // 当第一个、第二个、第三个筛选值同时存在时
            if (searchLists[0] && searchLists[1] && searchLists[2]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[3] == list[i][j].teachId) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第二个筛选值存在，第三个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && !searchLists[2]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[3] == list[i][j].teachId) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第三个筛选值存在，第二个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && searchLists[2]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[3] == list[i][j].teachId) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第二个、第三个筛选值存在，第一个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && searchLists[2]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[3] == list[i][j].teachId) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个筛选值存在，第二个、第三个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && !searchLists[2]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[3] == list[i][j].teachId) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第二个筛选值存在，第一个、第三个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && !searchLists[2]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[3] == list[i][j].teachId) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第三个筛选值存在，第一个、第二个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && searchLists[2]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[3] == list[i][j].teachId) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第二个、第三个筛选值都为空时，则在学员数组中查找是否有符合条件的信息
            else if (!searchLists[0] && !searchLists[1] && !searchLists[2]) {
                let list = this.data.list
                for (let i = 0; i < stuLists.length; i++) {
                    for (let j = 0; j < stuLists[i].length; j++) {
                        // 判断学生数组中是否有符合第二个筛选条件的信息
                        if (searchLists[3] == stuLists[i][j].teachId) {
                            // 将满足条件的学生信息添加进新数组
                            list.push(stuLists[i])
                            this.setData({
                                list
                            })
                        }
                    }
                }
                if (!list.length) {
                    return
                }
            }
        }
        // 当第五个筛选值不为空时，判断第五个筛选值是否符合要求
        if (searchLists[4]) {
            let flag = false
            let newList = []
            let list = this.data.list
            // 当第一个、第二个、第三个、第四个筛选值同时存在时
            if (searchLists[0] && searchLists[1] && searchLists[2] && searchLists[3]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[4] == list[i][j].teachEdu) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第二个、第三个筛选值存在，第四个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && searchLists[2] && !searchLists[3]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[4] == list[i][j].teachEdu) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第二个、第四个筛选值存在，第三个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && !searchLists[2] && searchLists[3]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[4] == list[i][j].teachEdu) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第三个、第四个筛选值存在，第二个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && searchLists[2] && searchLists[3]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[4] == list[i][j].teachEdu) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第二个、第三个、第四个筛选值存在，第一个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && searchLists[2] && searchLists[3]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[4] == list[i][j].teachEdu) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第二个筛选值存在，第三个、第四个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && !searchLists[2] && !searchLists[3]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[4] == list[i][j].teachEdu) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第三个筛选值存在，第二个、第四个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && searchLists[2] && !searchLists[3]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[4] == list[i][j].teachEdu) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第四个筛选值存在，第二个、第三个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && !searchLists[2] && searchLists[3]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[4] == list[i][j].teachEdu) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第二个、第三个筛选值存在，第一个、第四个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && searchLists[2] && !searchLists[3]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[4] == list[i][j].teachEdu) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第二个、第四个筛选值存在，第一个、第三个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && !searchLists[2] && searchLists[3]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[4] == list[i][j].teachEdu) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第三个、第四个筛选值存在，第一个、第二个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && searchLists[2] && searchLists[3]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[4] == list[i][j].teachEdu) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个筛选值存在，第二个、第三个、第四个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[4] == list[i][j].teachEdu) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第二个筛选值存在，第一个、第三个、第四个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && !searchLists[2] && !searchLists[3]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[4] == list[i][j].teachEdu) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第三个筛选值存在，第一个、第二个、第四个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && searchLists[2] && !searchLists[3]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[4] == list[i][j].teachEdu) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第四个筛选值存在，第一个、第二个、第三个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && !searchLists[2] && searchLists[3]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[4] == list[i][j].teachEdu) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第二个、第三个、第四个筛选值都为空时，则在学员数组中查找是否有符合条件的信息
            else if (!searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3]) {
                let list = this.data.list
                for (let i = 0; i < stuLists.length; i++) {
                    for (let j = 0; j < stuLists[i].length; j++) {
                        // 判断学生数组中是否有符合第二个筛选条件的信息
                        if (searchLists[4] == stuLists[i][j].teachEdu) {
                            // 将满足条件的学生信息添加进新数组
                            list.push(stuLists[i])
                            this.setData({
                                list
                            })
                        }
                    }
                }
                if (!list.length) {
                    return
                }
            }
        }
        // 当第六个筛选值不为空时，判断第六个筛选值是否符合要求
        if (searchLists[5]) {
            let flag = false
            let newList = []
            let list = this.data.list
            // 当第一个、第二个、第三个、第四个、第五个筛选值同时存在时
            if (searchLists[0] && searchLists[1] && searchLists[2] && searchLists[3] && searchLists[4]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第二个、第三个、第四个筛选值存在，第五个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && searchLists[2] && searchLists[3] && !searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第二个、第三个、第五个筛选值存在，第四个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && searchLists[2] && !searchLists[3] && searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第二个、第四个、第五个筛选值存在，第三个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && !searchLists[2] && searchLists[3] && searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第三个、第四个、第五个筛选值存在，第二个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && searchLists[2] && searchLists[3] && searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第二个、第三个、第四个、第五个筛选值存在，第一个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && searchLists[2] && searchLists[3] && searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第二个、第三个筛选值存在，第四个、第五个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && searchLists[2] && !searchLists[3] && !searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第二个、第四个筛选值存在，第三个、第五个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && !searchLists[2] && searchLists[3] && !searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第三个、第四个筛选值存在，第二个、第五个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && searchLists[2] && searchLists[3] && !searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第二个、第三个、第四个筛选值存在，第一个、第五个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && searchLists[2] && searchLists[3] && !searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第二个、第五个筛选值存在，第三个、第四个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && !searchLists[2] && !searchLists[3] && searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第三个、第五个筛选值存在，第二个、第四个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && searchLists[2] && !searchLists[3] && searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第二个、第三个、第五个筛选值存在，第一个、第四个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && searchLists[2] && !searchLists[3] && searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第四个、第五个筛选值存在，第二个、第三个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && !searchLists[2] && searchLists[3] && searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第二个、第四个、第五个筛选值存在，第一个、第三个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && !searchLists[2] && searchLists[3] && searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第三个、第四个、第五个筛选值存在，第一个、第二个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && searchLists[2] && searchLists[3] && searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第二个筛选值存在，第三个、第四个、第五个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && !searchLists[2] && !searchLists[3] && !searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第三个筛选值存在，第二个、第四个、第五个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && searchLists[2] && !searchLists[3] && !searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第二个、第三个筛选值存在，第一个、第四个、第五个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && searchLists[2] && !searchLists[3] && !searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第四个筛选值存在，第二个、第三个、第五个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && !searchLists[2] && searchLists[3] && !searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第二个、第四个筛选值存在，第一个、第三个、第五个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && !searchLists[2] && searchLists[3] && !searchLists[4]) {

                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第三个、第四个筛选值存在，第一个、第二个、第五个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && searchLists[2] && searchLists[3] && !searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个、第五个筛选值存在，第二个、第三个、第四个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3] && searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第二个、第五个筛选值存在，第一个、第三个、第四个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && !searchLists[2] && !searchLists[3] && searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第三个、第五个筛选值存在，第一个、第二个、第四个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && searchLists[2] && !searchLists[3] && searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第四个、第五个筛选值存在，第一个、第二个、第三个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && !searchLists[2] && searchLists[3] && searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个筛选值存在，第二个、第三个、第四个、第五个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3] && !searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第二个筛选值存在，第一个、第三个、第四个、第五个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && !searchLists[2] && !searchLists[3] && !searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第三个筛选值存在，第一个、第二个、第四个、第五个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && searchLists[2] && !searchLists[3] && !searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第四个筛选值存在，第一个、第二个、第三个、第五个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && !searchLists[2] && searchLists[3] && !searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第五个筛选值存在，第一个、第二个、第三个、第四个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3] && searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[5] == list[i][j].teachSex) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当前五个筛选值都不存在时
            else if (!searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3] && !searchLists[4]) {
                let list = this.data.list
                for (let i = 0; i < stuLists.length; i++) {
                    for (let j = 0; j < stuLists[i].length; j++) {
                        // 判断学生数组中是否有符合第二个筛选条件的信息
                        if (searchLists[5] == stuLists[i][j].teachSex) {
                            // 将满足条件的学生信息添加进新数组
                            list.push(stuLists[i])
                            this.setData({
                                list
                            })
                        }
                    }
                }
                if (!list.length) {
                    return
                }
            }
        }

        // 当第七个筛选值不为空时，判断第七个筛选值是否符合要求
        if (searchLists[6]) {
            let flag = false
            let newList = []
            let list = this.data.list
            // 当第一个、第二个、第三个、第四个、第五个、第六个筛选值同时存在时
            if (searchLists[0] && searchLists[1] && searchLists[2] && searchLists[3] && searchLists[4] && searchLists[5]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('1');
            }
            // 当第一个、第二个、第三个、第四个、第五个筛选值存在，第六个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && searchLists[2] && searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('2');
            }
            // 当第一个、第二个、第三个、第四个、第六个筛选值存在，第五个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && searchLists[2] && searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('3');
            }
            // 当第一个、第二个、第三个、第五个、第六个筛选值存在，第四个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && searchLists[2] && !searchLists[3] && searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('4');
            }
            // 当第一个、第二个、第四个、第五个、第六个筛选值存在，第三个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && !searchLists[2] && searchLists[3] && searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('5');
            }
            // 当第一个、第三个、第四个、第五个、第六个筛选值存在，第二个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && searchLists[2] && searchLists[3] && searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('6');
            }
            // 当第二个、第三个、第四个、第五个、第六个筛选值存在，第一个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && searchLists[2] && searchLists[3] && searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('7');
            }
            // 当第一个、第二个、第三个、第四个筛选值存在，第五个、第六个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && searchLists[2] && searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('8');
            }
            // 当第一个、第二个、第三个、第五个筛选值存在，第四个、第六个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && searchLists[2] && !searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('9');
            }
            // 当第一个、第二个、第四个、第五个筛选值存在，第三个、第六个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && !searchLists[2] && searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('10');
            }
            // 当第一个、第三个、第四个、第五个筛选值存在，第二个、第六个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && searchLists[2] && searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('11');
            }
            // 当第二个、第三个、第四个、第五个筛选值存在，第一个、第六个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && searchLists[2] && searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('12');
            }
            // 当第一个、第二个、第三个、第六个筛选值存在，第四个、第五个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && searchLists[2] && !searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('13');
            }
            // 当第一个、第二个、第四个、第六个筛选值存在，第三个、第五个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && !searchLists[2] && searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('14');
            }
            // 当第一个、第三个、第四个、第六个筛选值存在，第二个、第五个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && searchLists[2] && searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('15');
            }
            // 当第二个、第三个、第四个、第六个筛选值存在，第一个、第五个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && searchLists[2] && searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('16');
            }
            // 当第一个、第二个、第五个、第六个筛选值存在，第三个、第四个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && !searchLists[2] && !searchLists[3] && searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('17');
            }
            // 当第一个、第三个、第五个、第六个筛选值存在，第二个、第四个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && searchLists[2] && !searchLists[3] && searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('18');
            }
            // 当第二个、第三个、第五个、第六个筛选值存在，第一个、第四个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && searchLists[2] && !searchLists[3] && searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('19');
            }
            // 当第一个、第四个、第五个、第六个筛选值存在，第二个、第三个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && !searchLists[2] && searchLists[3] && searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('20');
            }
            // 当第二个、第四个、第五个、第六个筛选值存在，第一个、第三个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && !searchLists[2] && searchLists[3] && searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('21');
            }
            // 当第三个、第四个、第五个、第六个筛选值存在，第一个、第二个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && searchLists[2] && searchLists[3] && searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('22');
            }
            // 当第一个、第二个、第三个筛选值存在，第四个、第五个、第六个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && searchLists[2] && !searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('23');
            }
            // 当第一个、第二个、第四个筛选值存在，第三个、第五个、第六个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && !searchLists[2] && searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('24');
            }
            // 当第一个、第三个、第四个筛选值存在，第二个、第五个、第六个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && searchLists[2] && searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('25');
            }
            // 当第二个、第三个、第四个筛选值存在，第一个、第五个、第六个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && searchLists[2] && searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('26');
            }
            // 当第一个、第二个、第五个筛选值存在，第三个、第四个、第六个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && !searchLists[2] && !searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('27');
            }
            // 当第一个、第三个、第五个筛选值存在，第二个、第四个、第六个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && searchLists[2] && !searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('28');
            }
            // 当第二个、第三个、第五个筛选值存在，第一个、第四个、第六个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && searchLists[2] && !searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('29');
            }
            // 当第一个、第四个、第五个筛选值存在，第二个、第三个、第六个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && !searchLists[2] && searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('30');
            }
            // 当第二个、第四个、第五个筛选值存在，第一个、第三个、第六个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && !searchLists[2] && searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('31');
            }
            // 当第三个、第四个、第五个筛选值存在，第一个、第二个、第六个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && searchLists[2] && searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('32');
            }
            // 当第一个、第二个、第六个筛选值存在，第三个、第四个、第五个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && !searchLists[2] && !searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('33');
            }
            // 当第一个、第三个、第六个筛选值存在，第二个、第四个、第五个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && searchLists[2] && !searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('34');
            }
            // 当第二个、第三个、第六个筛选值存在，第一个、第四个、第五个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && searchLists[2] && !searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('35');
            }
            // 当第一个、第四个、第六个筛选值存在，第二个、第三个、第五个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && !searchLists[2] && searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('36');
            }
            // 当第二个、第四个、第六个筛选值存在，第一个、第三个、第五个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && !searchLists[2] && searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('37');
            }
            // 当第三个、第四个、第六个筛选值存在，第一个、第二个、第五个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && searchLists[2] && searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('38');
            }
            // 当第一个、第五个、第六个筛选值存在，第二个、第三个、第四个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3] && searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('39');
            }
            // 当第二个、第五个、第六个筛选值存在，第一个、第三个、第四个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && !searchLists[2] && !searchLists[3] && searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('40');
            }
            // 当第三个、第五个、第六个筛选值存在，第一个、第二个、第四个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && searchLists[2] && !searchLists[3] && searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('41');
            }
            // 当第四个、第五个、第六个筛选值存在，第一个、第二个、第三个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && !searchLists[2] && searchLists[3] && searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('42');
            }
            // 当第一个、第二个筛选值存在，第三个、第四个、第五个、第六个筛选值不存在时
            else if (searchLists[0] && searchLists[1] && !searchLists[2] && !searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('43');
            }
            // 当第一个、第三个筛选值存在，第二个、第四个、第五个、第六个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && searchLists[2] && !searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('44');
            }
            // 当第二个、第三个筛选值存在，第一个、第四个、第五个、第六个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && searchLists[2] && !searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('45');
            }
            // 当第一个、第四个筛选值存在，第二个、第三个、第五个、第六个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && !searchLists[2] && searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('46');
            }
            // 当第二个、第四个筛选值存在，第一个、第三个、第五个、第六个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && !searchLists[2] && searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('47');
            }
            // 当第三个、第四个筛选值存在，第一个、第二个、第五个、第六个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && searchLists[2] && searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('48');
            }
            // 当第一个、第五个筛选值存在，第二个、第三个、第四个、第六个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('49');
            }
            // 当第二个、第五个筛选值存在，第一个、第三个、第四个、第六个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && !searchLists[2] && !searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('50');
            }
            // 当第三个、第五个筛选值存在，第一个、第二个、第四个、第六个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && searchLists[2] && !searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('51');
            }
            // 当第四个、第五个筛选值存在，第一个、第二个、第三个、第六个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && !searchLists[2] && searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('52');
            }
            // 当第一个、第六个筛选值存在，第二个、第三个、第四个、第五个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('53');
            }
            // 当第二个、第六个筛选值存在，第一个、第三个、第四个、第五个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && !searchLists[2] && !searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('54');
            }
            // 当第三个、第六个筛选值存在，第一个、第二个、第四个、第五个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && searchLists[2] && !searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('55');
            }
            // 当第四个、第六个筛选值存在，第一个、第二个、第三个、第五个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && !searchLists[2] && searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('56');
            }
            // 当第五个、第六个筛选值存在，第一个、第二个、第三个、第四个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3] && searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('57');
            }
            // 当第一个筛选值存在，第二个、第三个、第四个、第五个、第六个筛选值不存在时
            else if (searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('58');
            }
            // 当第二个筛选值存在，第一个、第三个、第四个、第五个、第六个筛选值不存在时
            else if (!searchLists[0] && searchLists[1] && !searchLists[2] && !searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('59');
            }
            // 当第三个筛选值存在，第一个、第二个、第四个、第五个、第六个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && searchLists[2] && !searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('60');
            }
            // 当第四个筛选值存在，第一个、第二个、第三个、第五个、第六个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && !searchLists[2] && searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('61');
            }
            // 当第五个筛选值存在，第一个、第二个、第三个、第四个、第六个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3] && searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('62');
            }
            // 当第六个筛选值存在，第一个、第二个、第三个、第四个、第五个筛选值不存在时
            else if (!searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3] && !searchLists[4] && searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (searchLists[6] == list[i][j].teachImg) {
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('63');
            }
            // 当前六个筛选值都不存在时
            else if (!searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3] && !searchLists[4] && !searchLists[5]) {
                let list = this.data.list
                for (let i = 0; i < stuLists.length; i++) {
                    for (let j = 0; j < stuLists[i].length; j++) {
                        // 判断学生数组中是否有符合第二个筛选条件的信息
                        if (searchLists[6] == stuLists[i][j].teachImg) {
                            // 将满足条件的学生信息添加进新数组
                            list.push(stuLists[i])
                            this.setData({
                                list
                            })
                        }
                    }
                }
                if (!list.length) {
                    return
                }
                console.log('64');
            }
        }
    },


    // 清除选择按钮
    clearOptions() {
        searchLists = []
        this.setData({
            // 点击清除选择按钮后，将所有选项置为空
            isSearch: false,
            courseDetailChosed: '',
            teachPositionChosed: '',
            stuSexChosed: '',
            teachTypeChosed: '',
            teachEduChosed: '',
            teachSexChosed: '',
            teachImgChosed: '',
            list: [],

            // 将筛选选项区全部置为false（关闭筛选选项区）
            showCourse: false,
            showCourseDetail: false,
            showTeachPosition: false,
            showSexList: false,
            showTeachType: false,
            showTeachEdu: false,
            showTeachSex: false,
            showTeachImg: false
        })
    },

    /**
     * 生命周期函数--监听页面初次渲染完成
     */
    onReady() {

    },

    /**
     * 生命周期函数--监听页面显示
     */
    onShow() {

    },

    /**
     * 生命周期函数--监听页面隐藏
     */
    onHide() {

    },

    /**
     * 生命周期函数--监听页面卸载
     */
    onUnload() {

    },

    /**
     * 页面相关事件处理函数--监听用户下拉动作
     */
    onPullDownRefresh() {
        wx.startPullDownRefresh()
    },

    /**
     * 页面上拉触底事件的处理函数
     */
    onReachBottom() {
        wx.showToast({
            title: '没有更多了',
            icon: 'none'
        })
    },

    /**
     * 用户点击右上角分享
     */
    onShareAppMessage() {

    }
})