zj-teach/pages/teacherList/teacherList.js

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

    /**
     * 页面的初始数据
     */
    data: {
        toSearch: false, //是否打开找老师的筛选区
        courseChosedIndex: '', //选中科目的索引
        showCourse: false, //科目选项区是否显示
        courseDetailChosed: '', //课程详情筛选条件
        courseDetailIndex: '', //选中课程详情的索引
        showCourseDetail: false, //课程详情选项区是否显示
        teachIdChosed: '', //老师身份的筛选条件
        showTeachId: false, //老师身份选项区是否显示
        teachEduChosed: '', //老师学历的筛选条件
        showTeachEdu: false, //老师学历选项区是否显示
        teachSexChosed: '', //老师性别的筛选条件
        showTeachSex: false, //老师性别选项区是否显示
        schoolChosed: '', //老师大学的筛选条件
        showSchool: 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、老师身份
        teachId: ['不限', '专业老师', '在校大学生'],
        // 3、学历
        educationList: ['不限', '博士毕业', '博士在读', '硕士毕业', '硕士在读', '本科毕业', '本科在读', '专科毕业', '专科在读'],
        // 4、老师性别
        teachSex: ['不限', '男', '女'],
        // 5、大学列表，从遍历老师列表获取
        schoolList: ['不限'],
        // 6、老师照片选项
        teachImgOptions: ['不限', '有照片'],
        // 模拟后台读取的老师信息列表
        teachLists: [
            [{
                    imgUrl: '../../images/zly.jpeg'
                },
                {
                    firstName: '赵'
                },
                {
                    lastName: '丽颖'
                },
                {
                    sex: '女'
                },
                {
                    id: '专业老师'
                },
                {
                    teachEdu: '专科毕业'
                },
                {
                    school: '四川大学'
                },
                {
                    date: '2022-7-8'
                },
                {
                    teachYear: '5'
                },
                {
                    suc: '20'
                },
                {
                    newDate: '2022年8月8日'
                },
                {
                    ncd: '小学1-5数学'
                },
                {
                    cList: ['小学1-5数学']
                },
                {
                    cType: '小学'
                },
                {
                    selfIntroduce: '第一位'
                }
            ],
            [{
                    imgUrl: '../../images/zly.jpeg'
                },
                {
                    firstName: '钱'
                },
                {
                    lastName: '多多'
                },
                {
                    sex: '女'
                },
                {
                    id: '在校大学生'
                },
                {
                    teachEdu: '本科在读'
                },
                {
                    school: '电子科技大学'
                },
                {
                    date: '2022-9-21'
                },
                {
                    teachYear: '2'
                },
                {
                    suc: '10'
                },
                {
                    newDate: '2022年8月8日'
                },
                {
                    ncd: '初一初二英语'
                },
                {
                    cList: ['小学1-5语文', '初一初二英语']
                },
                {
                    cType: '小学'
                },
                {
                    selfIntroduce: '第二位'
                }
            ],
            [{
                    imgUrl: ''
                },
                {
                    firstName: '孙'
                },
                {
                    lastName: '悟空'
                },
                {
                    sex: '男'
                },
                {
                    id: '在校大学生'
                },
                {
                    teachEdu: '本科在读'
                },
                {
                    school: '西南交通大学'
                },
                {
                    date: '2022-9-21'
                },
                {
                    teachYear: '2'
                },
                {
                    suc: '10'
                },
                {
                    newDate: '2022年8月8日'
                },
                {
                    ncd: '初一初二语文'
                },
                {
                    cList: ['小学1-5语文', '初一初二语文']
                },
                {
                    cType: '小学,初中'
                },
                {
                    selfIntroduce: '第三位'
                }
            ],
            [{
                    imgUrl: ''
                },
                {
                    firstName: '李'
                },
                {
                    lastName: '子'
                },
                {
                    sex: '女'
                },
                {
                    id: '专业老师'
                },
                {
                    teachEdu: '硕士毕业'
                },
                {
                    school: '四川师范大学'
                },
                {
                    date: '2022-9-21'
                },
                {
                    teachYear: '4'
                },
                {
                    suc: '8'
                },
                {
                    newDate: '2022年8月8日'
                },
                {
                    ncd: '高一高二语文'
                },
                {
                    cList: ['高一高二语文']
                },
                {
                    cType: '高中'
                },
                {
                    selfIntroduce: '第四位'
                }
            ],
            [{
                    imgUrl: '../../images/zly.jpeg'
                },
                {
                    firstName: '周'
                },
                {
                    lastName: '丽颖'
                },
                {
                    sex: '女'
                },
                {
                    id: '专业老师'
                },
                {
                    teachEdu: '本科毕业'
                },
                {
                    school: '四川大学'
                },
                {
                    date: '2022-7-8'
                },
                {
                    teachYear: '5'
                },
                {
                    suc: '20'
                },
                {
                    newDate: '2022年8月8日'
                },
                {
                    ncd: '小学1-5数学'
                },
                {
                    cList: ['小学1-5数学']
                },
                {
                    cType: '小学'
                },
                {
                    selfIntroduce: '第五位'
                }
            ],
            [{
                    imgUrl: '../../images/zly.jpeg'
                },
                {
                    firstName: '吴'
                },
                {
                    lastName: '丽颖'
                },
                {
                    sex: '女'
                },
                {
                    id: '在校大学生'
                },
                {
                    teachEdu: '硕士在读'
                },
                {
                    school: '电子科技大学'
                },
                {
                    date: '2022-7-8'
                },
                {
                    teachYear: '5'
                },
                {
                    suc: '20'
                },
                {
                    newDate: '2022年8月8日'
                },
                {
                    ncd: '小学1-5数学'
                },
                {
                    cList: ['小学1-5数学']
                },
                {
                    cType: '小学'
                },
                {
                    selfIntroduce: '第六位'
                }
            ],
            [{
                    imgUrl: ''
                },
                {
                    firstName: '郑'
                },
                {
                    lastName: '悟空'
                },
                {
                    sex: '男'
                },
                {
                    id: '在校大学生'
                },
                {
                    teachEdu: '本科在读'
                },
                {
                    school: '西南交通大学'
                },
                {
                    date: '2022-9-21'
                },
                {
                    teachYear: '2'
                },
                {
                    suc: '10'
                },
                {
                    newDate: '2022年8月8日'
                },
                {
                    ncd: '初一初二英语'
                },
                {
                    cList: ['小学1-5语文', '初一初二英语']
                },
                {
                    cType: '小学,初中'
                },
                {
                    selfIntroduce: '第七位'
                }
            ],
            [{
                    imgUrl: ''
                },
                {
                    firstName: '王'
                },
                {
                    lastName: '子'
                },
                {
                    sex: '女'
                },
                {
                    id: '专业老师'
                },
                {
                    teachEdu: '本科毕业'
                },
                {
                    school: '成都大学'
                },
                {
                    date: '2022-9-21'
                },
                {
                    teachYear: '4'
                },
                {
                    suc: '8'
                },
                {
                    newDate: '2022年8月8日'
                },
                {
                    ncd: '高一高二语文'
                },
                {
                    cList: ['高一高二语文']
                },
                {
                    cType: '高中'
                },
                {
                    selfIntroduce: '第八位'
                }
            ],
        ]
    },

    /**
     * 生命周期函数--监听页面加载
     */
    onLoad(options) {
        // 遍历老师列表，获取大学信息
        let teachLists = this.data.teachLists
        let schoolList = this.data.schoolList
        // 遍历老师列表
        for (let i = 0; i < teachLists.length; i++) {
            // 遍历每个老师信息
            for (let j = 0; j < teachLists[i].length; j++) {
                // 判断每个老师信息中大学是否存在，如果存在，写入数组
                if (teachLists[i][j].school) {
                    // console.log(teachLists[i][j].school);
                    schoolList[i + 1] = teachLists[i][j].school
                }
            }
        }
        // console.log(schoolList);
        // 大学去重（方法一）
        // for (let i = 0; i < schoolList.length - 1; i++) {
        //     // console.log(schoolList[i]);
        //     for (let j = i + 1; j < schoolList.length; j++) {
        //         // console.log(schoolList[j]);
        //         if (schoolList[i] == schoolList[j]) {
        //             schoolList.splice(j, 1)
        //             j--
        //         }
        //     }
        // }
        // console.log(schoolList);
        // this.setData({
        //     schoolList
        // })

        // 大学去重（方法二）
        // 使用Set方法去重，得到的是类数组
        let newArr = new Set(schoolList)
        // 结合Array.from，转换成真实的数组，两条语句也可以合并为一条：Array.from(new Set(schoolList))
        // console.log(Array.from(newArr));
        // 将去重后的新数组赋值给schoolList，得到想要的结果
        schoolList = Array.from(newArr)
        this.setData({
            schoolList
        })
        // console.log(schoolList);
    },

    // 跳转到老师详情页
    toTeachDetail() {
        wx.redirectTo({
            url: '/pages/teachDetail/teachDetail',
        })
    },

    // 打开找老师的筛选区
    toOpenSearch() {
        let toSearch = this.data.toSearch
        this.setData({
            toSearch: !toSearch
        })
        // 判断打开找老师的筛选区的条件是否为false，如果是，则关闭所有选项的筛选区
        if (!this.data.toSearch) {
            this.setData({
                showTeachId: false,
                showCourse: false,
                showCourseDetail: false,
                showTeachEdu: false,
                showTeachSex: false,
                showSchool: false,
                showTeachImg: false
            })
        }
    },

    // 科目筛选项
    // 打开科目选项区，关闭其他选项区
    chooseCourse() {
        let showCourse = this.data.showCourse
        this.setData({
            showTeachId: false,
            showCourse: !showCourse,
            showCourseDetail: false,
            showTeachEdu: false,
            showTeachSex: false,
            showSchool: 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
        // let courseDetailChosed = this.data.courseDetailChosed
        this.setData({
            courseDetailChosed: courseDetail[courseChosedIndex][index],
            showCourseDetail: false,
            showCourse: false,
            courseDetailIndex: index
        })
        searchLists[0] = this.data.courseDetailChosed
        // console.log(this.data.courseDetailChosed);
    },
    // 课程详情取消图标的功能
    cancelChooseCourse() {
        searchLists[0] = ''
        this.setData({
            courseDetailChosed: '',
            showCourse: false,
            showCourseDetail: false
        })
    },

    // 老师身份筛选项
    // 打开老师身份选项区，关闭其他选项区
    chooseTeachId() {
        let showTeachId = this.data.showTeachId
        this.setData({
            showTeachId: !showTeachId,
            showCourse: false,
            showCourseDetail: false,
            showTeachEdu: false,
            showTeachSex: false,
            showSchool: false,
            showTeachImg: false
        })
    },

    // 选择老师身份
    toChosedTeachId(e) {
        // console.log(e);
        let index = e.currentTarget.dataset.index
        let teachIdChosed = this.data.teachIdChosed
        let teachId = this.data.teachId
        for (let i = 0; i < teachId.length; i++) {
            if (i == index) {
                teachIdChosed = teachId[i]
            }
        }
        this.setData({
            teachIdChosed,
            showTeachId: false
        })
        searchLists[1] = this.data.teachIdChosed
    },
    // 老师身份取消图标的功能
    cancelChooseTeachId() {
        searchLists[1] = ''
        this.setData({
            teachIdChosed: '',
            showTeachId: false
        })
    },

    // 老师学历筛选项
    // 打开老师学历选项区，关闭其他选项区
    chooseTeachEdu() {
        let showTeachEdu = this.data.showTeachEdu
        this.setData({
            showTeachId: false,
            showCourse: false,
            showCourseDetail: false,
            showTeachEdu: !showTeachEdu,
            showTeachSex: false,
            showSchool: 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[2] = this.data.teachEduChosed
    },
    // 老师学历取消图标的功能
    cancelChooseTeachEdu() {
        searchLists[2] = ''
        this.setData({
            teachEduChosed: '',
            showTeachEdu: false
        })
    },

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

    // 大学筛选项
    // 打开大学筛选选项区，关闭其他选项区
    chooseSchool() {
        let showSchool = this.data.showSchool
        this.setData({
            showTeachId: false,
            showCourse: false,
            showCourseDetail: false,
            showTeachEdu: false,
            showTeachSex: false,
            showSchool: !showSchool,
            showTeachImg: false
        })
    },
    // 选择大学
    toChosedSchool(e) {
        let index = e.currentTarget.dataset.index
        let schoolChosed = this.data.schoolChosed
        let schoolList = this.data.schoolList
        for (let i = 0; i < schoolList.length; i++) {
            if (i == index) {
                schoolChosed = schoolList[i]
            }
        }
        this.setData({
            schoolChosed,
            showSchool: false
        })
        searchLists[4] = this.data.schoolChosed
    },
    // 大学取消图标的功能
    cancelChooseSchool() {
        searchLists[4] = ''
        this.setData({
            schoolChosed: '',
            showSchool: false
        })
    },

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

    // 选择老师照片筛选条件
    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[5] = this.data.teachImgChosed
    },
    // 老师照片取消图标的功能
    cancelChooseTeachImg() {
        searchLists[5] = ''
        this.setData({
            teachImgChosed: '',
            showTeachImg: false
        })
    },

    // 搜索按钮功能
    handleSearch() {
        // 点击搜索按钮后，将筛选选项区全部置为false（关闭筛选选项区）
        this.setData({
            showTeachImg: false,
            showTeachId: false,
            showCourse: false,
            showCourseDetail: false,
            showTeachEdu: false,
            showTeachSex: false,
            showSchool: false
        })
        // console.log(searchLists[0]);
        // 判断搜索条件的数组是否为空（即是否选择了搜索条件）
        if (!searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3] && !searchLists[4] && !searchLists[5]) {
            this.setData({
                isSearch: false
            })
            wx.showToast({
                title: '您还没选择搜索条件',
                icon: 'none'
            })
            return
        }
        // 当搜索条件数组不为空时，点击搜索按钮后，重新将筛选后的数组设置为空数组，并将是否点击搜索的条件置为true
        this.setData({
            list: [],
            isSearch: true
        })
        let teachLists = this.data.teachLists
        let list = this.data.list
        // 当第一个筛选值存在时,判断第一个筛选值是否符合要求
        if (searchLists[0]) {
            for (let i = 0; i < teachLists.length; i++) {
                // console.log(teachLists[i][12].cList);
                for (let j = 0; j < teachLists[i][12].cList.length; j++) {
                    // console.log(teachLists[i][12].cList[j]);
                    // 判断老师列表中是否有符合第一项筛选条件的信息
                    if (searchLists[0] == teachLists[i][12].cList[j]) {
                        // console.log('ok');
                        // 将满足条件的老师信息添加进新数组
                        list.push(teachLists[i])
                        this.setData({
                            list
                        })
                    }
                }
            }
            // console.log('list第一个：',list);
            if (!list.length) {
                return
            }
        }

        // 当第二个筛选值存在，且第二个筛选值不等于“不限”时
        if (searchLists[1] && searchLists[1] != '不限') {
            let flag = false
            let newList = []
            let list = this.data.list
            // 当第一个筛选值存在时
            if (searchLists[0] && searchLists[1] != '不限') {
                /* 
                    当第一个筛选项存在时，设置局部变量flag初始值为false，用来判断第二个筛选项在筛选后
                    的数组中是否能找到符合条件的信息，如果能找到，则将flag的值改为true
                */
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        // 判断满足第一个筛选条件的新数组中是否有符合第二个筛选条件的信息
                        if (searchLists[1] == list[i][j].id) {
                            // 将满足条件的老师信息添加进新数组
                            newList.push(list[i])
                            this.setData({
                                list: newList
                            })
                            // 如果有满足第二个筛选条件的信息，则将flag的值改为true
                            flag = true
                        }
                    }
                }
                // console.log('flag',flag);
                // 如果在满足第一个筛选条件的数组中，没有满足第二个筛选条件的信息，则将筛选后的数组置为空数组
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
            }
            // 当第一个筛选值不存在时
            else if (!searchLists[0]) {
                let list = this.data.list
                // 当第一项筛选值为空时，则在教师数组中查找是否有符合条件的信息
                for (let i = 0; i < teachLists.length; i++) {
                    for (let j = 0; j < teachLists[i].length; j++) {
                        if (searchLists[1] == teachLists[i][j].id) {
                            // 将满足条件的老师信息添加进新数组
                            list.push(teachLists[i])
                            this.setData({
                                list
                            })
                        }
                    }
                }
                if (!list.length) {
                    return
                }
            }
        }
        // 当第二个筛选值存在，且第二个筛选值等于“不限”时
        else if (searchLists[1] && searchLists[1] == '不限') {
            if (!searchLists[0]) {
                this.setData({
                    list: teachLists
                })
            }
        }
        // 当第二个筛选值存在，且第二个筛选值等于“不限”，若第一个筛选值存在，就不进行其他操作

        // 当第三个筛选值存在，且不等于“不限”时
        if (searchLists[2] && 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].teachEdu) {
                            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]) {
                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].teachEdu) {
                            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]) {
                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].teachEdu) {
                            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]) {
                let list = this.data.list
                for (let i = 0; i < teachLists.length; i++) {
                    for (let j = 0; j < teachLists[i].length; j++) {
                        if (searchLists[2] == teachLists[i][j].teachEdu) {
                            // 将满足条件的老师信息添加进新数组
                            list.push(teachLists[i])
                            this.setData({
                                list
                            })
                            flag = true
                        }
                    }
                }
                if (!list.length) {
                    return
                }
                // console.log('4');
            }
        }
        // 当第三个筛选值存在，且等于“不限”时
        else if (searchLists[2] && searchLists[2] == '不限') {
            // 如果第一个、第二个筛选值都不存在
            if (!searchLists[0] && !searchLists[1]) {
                this.setData({
                    list: teachLists
                })
                // console.log('5');
            }
        }
        // 当第三个筛选值存在，且第三个值等于“不限”时，如果第一个和第二个只要有一个不为空，就不进行其他操作

        // 当第四个筛选值存在，且不等于“不限”时
        if (searchLists[3] && 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].sex) {
                            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]) {
                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].sex) {
                            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]) {
                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].sex) {
                            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]) {
                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].sex) {
                            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]) {
                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].sex) {
                            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]) {
                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].sex) {
                            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]) {
                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].sex) {
                            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]) {
                let list = this.data.list
                for (let i = 0; i < teachLists.length; i++) {
                    for (let j = 0; j < teachLists[i].length; j++) {
                        if (searchLists[3] == teachLists[i][j].sex) {
                            // 将满足条件的老师信息添加进新数组
                            list.push(teachLists[i])
                            this.setData({
                                list
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('8');
            }
        }
        // 当第四个筛选值存在，且等于“不限”时
        else if (searchLists[3] && searchLists[3] == '不限') {
            // 如果前三个筛选值都不存在
            if (!searchLists[0] && !searchLists[1] && !searchLists[2]) {
                this.setData({
                    list: teachLists
                })
                console.log('9');
            }
        }
        // 当第四个筛选值存在，且第四个值等于“不限”时，如果前三个只要有一个不为空，就不进行其他操作


        // 当第五个筛选值存在，且不等于“不限”时
        if (searchLists[4] && 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].school) {
                            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]) {
                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].school) {
                            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]) {
                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].school) {
                            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]) {
                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].school) {
                            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]) {
                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].school) {
                            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]) {
                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].school) {
                            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]) {
                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].school) {
                            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]) {
                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].school) {
                            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]) {
                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].school) {
                            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]) {
                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].school) {
                            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]) {
                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].school) {
                            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]) {
                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].school) {
                            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]) {
                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].school) {
                            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]) {
                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].school) {
                            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]) {
                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].school) {
                            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]) {
                let list = this.data.list
                for (let i = 0; i < teachLists.length; i++) {
                    for (let j = 0; j < teachLists[i].length; j++) {
                        if (searchLists[4] == teachLists[i][j].school) {
                            // 将满足条件的老师信息添加进新数组
                            list.push(teachLists[i])
                            this.setData({
                                list
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('16');
            }
        }
        // 当第五个筛选值存在，且等于“不限”时
        else if (searchLists[4] && searchLists[4] == '不限') {
            // 如果前四个筛选值都不存在
            if (!searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3]) {
                this.setData({
                    list: teachLists
                })
                console.log('17');
            }
        }

        // 当第六个筛选值存在，且不等于“不限”时
        if (searchLists[5] && 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++) {
                        // console.log(list[i][j].imgUrl);
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                for (let i = 0; i < list.length; i++) {
                    for (let j = 0; j < list[i].length; j++) {
                        if (list[i][j].imgUrl) {
                            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]) {
                let list = this.data.list
                for (let i = 0; i < teachLists.length; i++) {
                    for (let j = 0; j < teachLists[i].length; j++) {
                        if (teachLists[i][j].imgUrl) {
                            // 将满足条件的老师信息添加进新数组
                            list.push(teachLists[i])
                            this.setData({
                                list
                            })
                            flag = true
                        }
                    }
                }
                if (!flag) {
                    this.setData({
                        list: []
                    })
                    return
                }
                console.log('32');
            }
        }
        // 当第六个筛选值存在，且等于“不限”时
        else if (searchLists[5] && searchLists[5] == '不限') {
            // 如果前五个筛选值都不存在
            if (!searchLists[0] && !searchLists[1] && !searchLists[2] && !searchLists[3] && !searchLists[3]) {
                this.setData({
                    list: teachLists
                })
                console.log('33');
            }
        }
    },

    // 清除选择按钮
    clearOptions() {
        searchLists = []
        this.setData({
            courseChosedIndex: '',
            courseDetailIndex: '',
            courseDetailChosed: '',
            teachIdChosed: '',
            teachEduChosed: '',
            teachSexChosed: '',
            schoolChosed: '',
            teachImgChosed: '',

            // 将筛选选项区全部置为false（关闭筛选选项区）
            showTeachId: false,
            showCourse: false,
            showCourseDetail: false,
            showTeachEdu: false,
            showTeachSex: false,
            showSchool: false,
            showTeachImg: false

        })
    },

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

    },

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

    },

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

    },

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

    },

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

    },

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

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

    }
})