array.some(callback(element[, index[, array]])[, thisArg])

const numbers = [10, 20, 30, 40];
// 同時(shí)使用三個參數(shù)
const hasEvenOverIndex1 = numbers.some((element, index, array) => {
     console.log(`元素：${element}，索引：${index}，原數(shù)組長度：${array.length}`);
     return element % 2 === 0 && index > 1;
});
console.log(hasEvenOverIndex1); // true（30滿足條件）

const validator = {
     min: 18,
     checkAge: function(age) {
       return age >= this.min; // this指向validator對象
     }
};
const users = [
     { name: "張三", age: 17 },
     { name: "李四", age: 20 },
     { name: "王五", age: 16 }
];
// 傳入thisArg為validator
const hasAdult = users.some(validator.checkAge, validator);
console.log(hasAdult); // true

const scores = [85, 42, 91, 33, 67];
// 檢測是否有分?jǐn)?shù)超過90
const hasHighScore = scores.some(score => score > 90);
console.log(hasHighScore); // true（91滿足條件）

const fruits = ["蘋果", "香蕉", "橙子", "葡萄"];
const target = "芒果";
const hasMango = fruits.some(fruit => fruit === target);
console.log(hasMango); // false

const permissions = [
     { name: "查看", isAdmin: false },
     { name: "編輯", isAdmin: false },
     { name: "刪除", isAdmin: true }
];
const hasAdminPerm = permissions.some(perm => perm.isAdmin);
console.log(hasAdminPerm); // true

const users = [
     { id: 1, name: "張三", city: "上海" },
     { id: 2, name: "李四", city: "北京" },
     { id: 3, name: "王五", city: "廣州" }
];
// 檢測城市屬性
const hasBeijingUser = users.some(user => user.city === "北京");
console.log(hasBeijingUser); // true

const products = [
     { name: "手機(jī)", category: "數(shù)碼", price: 3999 },
     { name: "微波爐", category: "家電", price: 899 },
     { name: "襯衫", category: "服飾", price: 199 }
];
const hasCheapAppliance = products.some(product =>    
     product.category === "家電" && product.price < 1000
);
console.log(hasCheapAppliance); // true

const emptyArray = [];
// 空數(shù)組調(diào)用some始終返回false
const result = emptyArray.some(item => item > 0);
console.log(result); // false

// 創(chuàng)建稀疏數(shù)組（索引1為空）
const sparseArray = [10, , 30, 40];
// 檢測是否有大于25的元素
const hasLargeNum = sparseArray.some(num => {
     console.log(num); // 輸出10、30、40（跳過空槽）
     return num > 25;
});
console.log(hasLargeNum); // true

const mixedArray = [123, "hello", true, { name: "張三" }, null];
// 檢測是否存在對象
const hasObject = mixedArray.some(item => typeof item === "object" && item!== null);
console.log(hasObject); // true

const multiArray = [[1,2], [3,4,5], [6]];
const hasLength3 = multiArray.some(subArray => subArray.length === 3);
console.log(hasLength3); // true

const orders = [
     { id: 1, amount: 150 },
     { id: 2, amount: 200 },
     { id: 3, amount: 80 }
];
// 先提取金額并乘以稅率，再檢測是否有超過200的稅費(fèi)后金額
const hasHighTaxAmount = orders
    .map(order => order.amount * 1.13) // 加13%稅費(fèi)
    .some(taxedAmount => taxedAmount > 200);
console.log(hasHighTaxAmount); // true（200*1.13=226）

const products = [
     { name: "筆記本", category: "數(shù)碼", price: 4999 },
     { name: "耳機(jī)", category: "數(shù)碼", price: 799 },
     { name: "冰箱", category: "家電", price: 2999 }
];
// 先篩選數(shù)碼類商品，再檢測是否有價(jià)格低于1000的
const hasCheapDigital = products
    .filter(product => product.category === "數(shù)碼")
    .some(product => product.price < 1000);
console.log(hasCheapDigital); // true（耳機(jī)799元）

function checkNegativeArgs() {
     // 將arguments轉(zhuǎn)為可迭代對象并調(diào)用some
     return Array.prototype.some.call(arguments, arg => arg < 0);
}
console.log(checkNegativeArgs(1, 3, -2)); // true
console.log(checkNegativeArgs(5, 7, 9)); // false

// 獲取所有按鈕元素（NodeList類數(shù)組）
const buttons = document.getElementsByTagName("button");
// 檢測是否有display為none的按鈕
const hasHiddenButton = Array.prototype.some.call(buttons, button => {
     return window.getComputedStyle(button).display === "none";
});
console.log(hasHiddenButton); // 布爾值，取決于頁面元素

const nestedArray = [
     [1, 2, 3],
     [4, [5, 6], 7],
     [8, 9]
];
// 遞歸檢測嵌套數(shù)組
function hasValueInNestedArray(arr, target) {
     return arr.some(item => {
       // 若元素是數(shù)組則遞歸檢測，否則直接比較
       return Array.isArray(item)? hasValueInNestedArray(item, target) : item === target;
     });
}
console.log(hasValueInNestedArray(nestedArray, 6)); // true
console.log(hasValueInNestedArray(nestedArray, 10)); // false

// 模擬異步請求函數(shù)
function fetchData(id) {
     return new Promise((resolve) => {
       setTimeout(() => {
         // 模擬id=2的請求成功，其他失敗
         if (id === 2) resolve({ success: true, data: {} });
         else resolve({ success: false });
       }, 1000);
     });
}
// 異步some實(shí)現(xiàn)
async function asyncSome(arr, asyncCallback) {
     for (const item of arr) {
       const result = await asyncCallback(item);
       if (result) return true; // 找到滿足條件的立即返回
     }
     return false;
}
// 使用異步some檢測請求
const requestIds = [1, 2, 3];
const hasSuccessfulRequest = await asyncSome(requestIds, async (id) => {
     const response = await fetchData(id);
     return response.success;
});
console.log(hasSuccessfulRequest); // true

// 模擬字段異步驗(yàn)證
const validateField = async (field) => {
     // 模擬用戶名唯一性校驗(yàn)
     if (field.name === "username") {
       return new Promise(resolve => {
         setTimeout(() => {
           resolve(field.value === "admin" ? false : true); // admin已存在
         }, 800);
       });
     }
     // 其他字段同步驗(yàn)證
     return field.value.trim()!== "";
};
// 表單字段
const formFields = [
     { name: "username", value: "admin" },
     { name: "password", value: "123456" },
     { name: "email", value: "" }
];
// 檢測是否有驗(yàn)證失敗的字段
const hasInvalidField = await asyncSome(formFields, validateField);
console.log(hasInvalidField); // false（username驗(yàn)證失?。?/pre>

// 表單數(shù)據(jù)
const formData = {
     username: "zhangsan",
     password: "",
     email: "zhangsan@example.com",
     phone: ""
};
// 必填字段列表
const requiredFields = ["username", "password", "phone"];
// 檢測是否有必填項(xiàng)為空
const hasEmptyRequired = requiredFields.some(field => {
     const value = formData[field];
     // 處理字符串、數(shù)字等不同類型的空值判斷
     return value === undefined || value === null || value.toString().trim() === "";
});
if (hasEmptyRequired) {
     console.log("請?zhí)顚懰斜靥钭侄?); // 執(zhí)行此邏輯
} else {
     console.log("表單驗(yàn)證通過");
}

const passwords = ["123456", "abcdef", "Abc123!", "Qwe@123"];
const specialChars = ["!", "@", "#", "$", "%"];
// 檢測密碼是否包含特殊字符
const hasValidPassword = passwords.some(password => {
     // 檢測當(dāng)前密碼是否包含任一特殊字符
     return specialChars.some(char => password.includes(char));
});
console.log(hasValidPassword); // true（后兩個密碼符合要求）

// 獲取所有輸入框
const inputs = document.querySelectorAll("input");
// 檢測是否有聚焦的輸入框
const hasActiveInput = Array.prototype.some.call(inputs, input => {
     return document.activeElement === input;
});
// 檢測是否有禁用的輸入框
const hasDisabledInput = Array.prototype.some.call(inputs, input => {
     return input.disabled;
});
console.log("是否有激活輸入框：", hasActiveInput);
console.log("是否有禁用輸入框：", hasDisabledInput);

const listItems = document.querySelectorAll(".list-item");
const maxAllowedHeight = 80; // 最大允許高度80px
// 檢測是否有元素高度超限
const hasOverHeightItem = Array.prototype.some.call(listItems, item => {
     return item.offsetHeight > maxAllowedHeight;
});
if (hasOverHeightItem) {
     console.log("存在高度超限的列表項(xiàng)");
     // 執(zhí)行樣式調(diào)整邏輯
}

// 當(dāng)前用戶權(quán)限
const userPermissions = ["view:user", "edit:order", "delete:product"];
// 檢測是否有指定權(quán)限
function hasPermission(targetPermission) {
     return userPermissions.some(perm => perm === targetPermission);
}
// 權(quán)限檢測示例
console.log(hasPermission("edit:user")); // false
console.log(hasPermission("edit:order")); // true

const dataList = [
     { id: 1, status: "valid", value: 100 },
     { id: 2, status: "invalid", value: null },
     { id: 3, status: "valid", value: 200 }
];
// 定義無效數(shù)據(jù)判斷規(guī)則
const isInvalid = item => item.status === "invalid" || item.value === null;
// 檢測是否有無效數(shù)據(jù)
const hasInvalidData = dataList.some(isInvalid);
if (hasInvalidData) {
     console.log("數(shù)據(jù)中存在無效項(xiàng)，開始過濾");
     const validData = dataList.filter(item =>!isInvalid(item));
     console.log("過濾后數(shù)據(jù)：", validData);
} else {
     console.log("數(shù)據(jù)全部有效，無需過濾");
}

// 模擬接口返回?cái)?shù)據(jù)
const apiResponses = [
     { code: 500, message: "服務(wù)器錯誤" },
     { code: 200, message: "成功", data: {} },
     { code: 404, message: "資源不存在" }
];
// 檢測是否有接口成功返回
const hasSuccessfulResponse = apiResponses.some(response => {
     return response.code === 200 && response.data!== undefined;
});
if (hasSuccessfulResponse) {
     console.log("存在成功的接口響應(yīng)");
     // 提取成功數(shù)據(jù)進(jìn)行處理
     const successData = apiResponses.find(response => response.code === 200).data;
} else {
     console.log("所有接口均失敗");
     // 執(zhí)行錯誤處理邏輯
}

// 請求參數(shù)
const requestParams = {
     page: 1,
     size: 20,
     sort: "createTime",
     filter: ""
};
// 參數(shù)驗(yàn)證規(guī)則
const paramRules = [
     { key: "page", validator: val => val >= 1 && val <= 100 },
     { key: "size", validator: val => val >= 10 && val <= 100 },
     { key: "filter", validator: val => val === "" || val.length >= 3 }
];
// 檢測參數(shù)是否符合規(guī)則
const hasInvalidParam = paramRules.some(rule => {
     const paramValue = requestParams[rule.key];
     return!rule.validator(paramValue);
});
if (hasInvalidParam) {
     console.log("參數(shù)不符合要求");
} else {
     console.log("參數(shù)驗(yàn)證通過，發(fā)起請求");
}

const numbers = [2, 4, 6, 7, 8];
// some：是否有奇數(shù)（存在→true）
const hasOdd = numbers.some(num => num % 2!== 0);
console.log(hasOdd); // true
// every：是否全是偶數(shù)（有奇數(shù)→false）
const allEven = numbers.every(num => num % 2 === 0);
console.log(allEven); // false

const users = [
     { id: 1, age: 17 },
     { id: 2, age: 20 },
     { id: 3, age: 22 }
];
// some：是否有成年用戶（返回布爾值）
const hasAdult = users.some(user => user.age >= 18);
console.log(hasAdult); // true
// find：找到第一個成年用戶（返回對象）
const firstAdult = users.find(user => user.age >= 18);
console.log(firstAdult); // { id: 2, age: 20 }

const largeArray = Array.from({ length: 10000 }, (_, i) => i + 1);
// some：檢測是否有大于9990的數(shù)字（很快，找到后停止）
console.time("some");
const hasLargeNum = largeArray.some(num => num > 9990);
console.timeEnd("some"); // 約0.1ms
console.log(hasLargeNum); // true
// filter：篩選大于9990的數(shù)字（遍歷全部元素）
console.time("filter");
const largeNums = largeArray.filter(num => num > 9990);
console.timeEnd("filter"); // 約0.5ms
console.log(largeNums.length > 0); // true

const products = [
     { id: 1, name: "蘋果" },
     { id: 2, name: "香蕉" },
     { id: 3, name: "橙子" }
];
// some：檢測是否有名稱包含“果”字的商品（復(fù)雜條件）
const hasFruit = products.some(product => product.name.includes("果"));
console.log(hasFruit); // true
// includes：無法直接檢測對象屬性，需配合map
const productNames = products.map(product => product.name);
const hasBanana = productNames.includes("香蕉");
console.log(hasBanana); // true

const numbers = [1, 3, 5, 7];
// 錯誤：回調(diào)無返回值，始終返回false
const hasOdd = numbers.some(num => {
     num % 2!== 0; // 缺少return
});
console.log(hasOdd); // false（錯誤結(jié)果）
// 正確寫法
const hasOddCorrect = numbers.some(num => num % 2!== 0);
console.log(hasOddCorrect); // true

const validator = {
     threshold: 100,
     check: function(value) {
       return value > this.threshold; // this可能指向錯誤
     }
};
const values = [90, 105, 110];
// 錯誤：this指向window，threshold為undefined
const hasOverThreshold = values.some(validator.check);
console.log(hasOverThreshold); // false（錯誤）
// 正確寫法1：使用bind綁定this
const hasOver1 = values.some(validator.check.bind(validator));
// 正確寫法2：使用箭頭函數(shù)
const hasOver2 = values.some(value => validator.check(value));
// 正確寫法3：傳入thisArg參數(shù)
const hasOver3 = values.some(validator.check, validator);
console.log(hasOver1, hasOver2, hasOver3); // 均為true

const emptyArr = [];
// 空數(shù)組調(diào)用some始終返回false，無論條件如何
const result1 = emptyArr.some(item => item > 0);
const result2 = emptyArr.some(item => false);
const result3 = emptyArr.some(item => true);
console.log(result1, result2, result3); // 均為false

function checkArray(arr, condition) {
     if (arr.length === 0) {
       console.warn("數(shù)組為空，返回默認(rèn)值false");
       return false;
     }
     return arr.some(condition);
}

// 稀疏數(shù)組（索引1和3為空）
const sparseArr = [10, , 30, , 50];
let count = 0;
// some會跳過空槽，僅處理有值的元素
const hasEven = sparseArr.some(item => {
     count++;
     return item % 2 === 0;
});
console.log(hasEven); // true
console.log(count); // 3（僅遍歷了10、30、50）

// 用undefined填充空槽
const filledArr = sparseArr.map(item => item);
// 再執(zhí)行some操作
const hasEvenFilled = filledArr.some(item => item % 2 === 0);

const urls = ["url1", "url2", "url3"];
// 錯誤：異步操作不會阻塞some的執(zhí)行
const hasValidUrl = urls.some(async (url) => {
     const response = await fetch(url);
     return response.ok; // 異步結(jié)果無法被some捕獲
});
console.log(hasValidUrl); // 立即返回true（錯誤結(jié)果）

// 正確：使用異步some函數(shù)
const hasValidUrl = await asyncSome(urls, async (url) => {
     const response = await fetch(url);
     return response.ok;
});
console.log(hasValidUrl); // 正確返回布爾值

const mixedArr = [0, 1, "2", false, null];
// 錯誤：0 == false為true，導(dǎo)致誤判
const hasFalse = mixedArr.some(item => item == false);
console.log(hasFalse); // true（0被誤判為false）
// 正確：使用===嚴(yán)格相等
const hasFalseStrict = mixedArr.some(item => item === false);
console.log(hasFalseStrict); // true（僅false被檢測到）

const products = [/* 大量商品數(shù)據(jù) */];
// 優(yōu)化前：先執(zhí)行復(fù)雜計(jì)算，再判斷
const hasCheapElectronics = products.some(product => {
     const tax = product.price * 0.13; // 復(fù)雜計(jì)算
     const total = product.price + tax;
     return product.category === "electronics" && total < 1000;
});
// 優(yōu)化后：先判斷簡單條件，不滿足則跳過復(fù)雜計(jì)算
const hasCheapElectronicsOpt = products.some(product => {
     // 先判斷分類，不滿足直接返回false
     if (product.category!== "electronics") return false;
     // 僅分類符合時(shí)才執(zhí)行復(fù)雜計(jì)算
     const tax = product.price * 0.13;
     const total = product.price + tax;
     return total < 1000;
});

async function chunkedSome(largeArray, condition, chunkSize = 1000) {
     const chunks = [];
     // 分割數(shù)組為多個分片
     for (let i = 0; i < largeArray.length; i += chunkSize) {
       chunks.push(largeArray.slice(i, i + chunkSize));
     }
     // 逐個分片執(zhí)行some，找到結(jié)果后立即返回
     for (const chunk of chunks) {
       const result = chunk.some(condition);
       if (result) return true;
       // 每處理一個分片，讓出主線程
       await new Promise(resolve => setTimeout(resolve, 0));
     }
     return false;
}
// 使用示例
const largeArray = Array.from({ length: 100000 }, (_, i) => i);
const hasTarget = await chunkedSome(largeArray, item => item === 99999);

// 優(yōu)化前：回調(diào)中包含DOM操作
const hasInvalidItem = items.some(item => {
     const element = document.createElement("div"); // 重型操作
     element.textContent = item.name;
     document.body.appendChild(element);
     return item.isInvalid;
});
// 優(yōu)化后：先執(zhí)行some判斷，再進(jìn)行DOM操作
const hasInvalidItemOpt = items.some(item => item.isInvalid);
if (hasInvalidItemOpt) {
     // 僅在需要時(shí)執(zhí)行DOM操作
     items.forEach(item => {
       if (item.isInvalid) {
         const element = document.createElement("div");
         element.textContent = item.name;
         document.body.appendChild(element);
       }
     });
}

if (!Array.prototype.some) {
     Array.prototype.some = function(callback, thisArg) {
       // 檢測回調(diào)是否為函數(shù)
       if (typeof callback!== "function") {
         throw new TypeError("callback must be a function");
       }
       // 轉(zhuǎn)換為對象，避免原始類型的問題
       const obj = Object(this);
       // 獲取數(shù)組長度（考慮稀疏數(shù)組）
       const len = obj.length >>> 0;
       for (let i = 0; i < len; i++) {
         // 僅處理已初始化的元素
         if (i in obj) {
           const value = obj[i];
           // 調(diào)用回調(diào)函數(shù)，綁定thisArg
           if (callback.call(thisArg, value, i, obj)) {
             return true; // 找到滿足條件的元素，立即返回
           }
         }
       }
       return false; // 所有元素均不滿足條件
     };
}

function someForArrayLike(arrayLike, callback, thisArg) {
     // 轉(zhuǎn)換類數(shù)組為真正的數(shù)組
     const arr = Array.prototype.slice.call(arrayLike);
     return arr.some(callback, thisArg);
}
// 使用示例
const args = arguments;
const hasNegative = someForArrayLike(args, arg => arg < 0);

interface User {
     id: number;
     name: string;
     age: number;
}
const users: User[] = [
     { id: 1, name: "張三", age: 17 },
     { id: 2, name: "李四", age: 20 }
];
// 類型安全的some調(diào)用
const hasAdult: boolean = users.some((user: User) => user.age >= 18);

function UserList({ users }) {
     // 優(yōu)化：使用useMemo緩存計(jì)算結(jié)果
     const hasAdmin = React.useMemo(() => {
       return users.some(user => user.role === "admin");
     }, [users]); // 僅當(dāng)users變化時(shí)重新計(jì)算
     return (
       <div>
         {hasAdmin && <div>存在管理員用戶</div>}
         <ul>{/* 用戶列表渲染 */}</ul>
       </div>
     );
}

<template>
     <div>
       <p v-if="hasCompleted">存在已完成的任務(wù)</p>
     </div>
</template>
<script>
export default {
     data() {
       return {
         tasks: [/* 任務(wù)數(shù)據(jù) */]
       };
     },
     computed: {
       // 使用計(jì)算屬性緩存結(jié)果
       hasCompleted() {
         return this.tasks.some(task => task.status === "completed");
       }
     }
};
</script>