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: '',
            searchLists
        })
    },

    // 辅导方式
    // 打开辅导方式筛选区，关闭其他选项筛选区
    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: '',
            searchLists
        })
    },

    // 选择学生性别筛选项
    // 打开学生性别选项区，关闭其他选项区
    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: '',
            searchLists
        })
    },

    // 教员类型筛选项
    // 打开老师身份选项区，关闭其他选项区
    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: '',
            searchLists
        })
    },

    // 老师学历筛选项
    // 打开老师学历选项区，关闭其他选项区
    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: '',
            searchLists
        })
    },

    // 选择老师性别筛选项
    // 打开老师性别选项区，关闭其他选项区
    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: '',
            searchLists
        })
    },

    // 老师照片筛选项
    // 打开老师照片选项区，关闭其他选项区
    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: '',
            searchLists
        })
    },

    // 搜索按钮功能
    onSearch() {
        // 点击搜索按钮后，将筛选选项区全部置为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
                }
            }
        }
    },


    // 清除选择按钮
    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() {

    }
})