前端操作方法

数组

方法	参数	操作	返回值	时间复杂度	空间复杂度
push()	一个或多个元素	在数组末尾添加一个或多个元素，并返回新数组的长度	新数组的长度	O(1)	O(1)
pop()	无	移除并返回数组的最后一个元素	被移除的元素	O(1)	O(1)
unshift()	一个或多个元素	在数组开头添加一个或多个元素，并返回新数组的长度	新数组的长度	O(n)	O(n)
shift()	无	移除并返回数组的第一个元素	被移除的元素	O(n)	O(n)
concat()	一个或多个数组	创建一个新数组，包含原数组和指定的数组	合并后的新数组	O(n)	O(n)
slice()	起始索引和结束索引（可选）	从原数组中返回选定的元素，生成一个新数组	选定的元素组成的新数组	O(k)	O(k)
splice()	起始索引、要删除的元素个数和要添加的元素（可选）	在指定位置修改数组，删除/添加元素	被删除的元素组成的新数组	O(n)	O(n)
indexOf()	要查找的元素和起始搜索位置（可选）	返回指定元素在数组中首次出现的位置，如果不存在则返回-1	元素的索引或-1	O(n)	O(1)
lastIndexOf()	要查找的元素和起始搜索位置（可选）	返回指定元素在数组中最后一次出现的位置，如果不存在则返回-1	元素的索引或-1	O(n)	O(1)
includes()	要查找的元素和起始搜索位置（可选）	判断数组是否包含指定元素	布尔值	O(n)	O(1)
join()	连接符（可选）	将数组中的所有元素连接成一个字符串	连接后的字符串	O(n)	O(n)
reverse()	无	颠倒数组中元素的顺序	颠倒顺序后的数组	O(n)	O(1)
sort()	排序比较函数（可选）	对数组元素进行排序，默认按照字母顺序排序	排序后的数组	O(n log(n))	O(log(n))
filter()	筛选条件函数	根据指定条件过滤数组中的元素，返回满足条件的新数组	满足条件的新数组	O(n)	O(n)
map()	转换函数	遍历数组，对每个元素执行指定操作，并返回新数组	转换后的新数组	O(n)	O(n)
forEach()	遍历函数	遍历数组，对每个元素执行指定操作，没有返回值	无	O(n)	O(1)
reduce()	累积函数和初始值（可选）	对数组中的元素执行累积操作，返回一个值	累积结果	O(n)	O(1)
find()	筛选条件函数	返回数组中满足条件的第一个元素，如果不存在则返回undefined	第一个满足条件的元素	O(n)	O(1)
findIndex()	筛选条件函数	返回数组中满足条件的第一个元素的索引，如果不存在则返回-1	第一个满足条件的索引	O(n)	O(1)
some()	筛选条件函数	检测数组中是否至少有一个元素满足指定条件	布尔值	O(n)	O(1)
every()	筛选条件函数	检测数组中是否所有元素都满足指定条件	布尔值	O(n)	O(1)

示例：

push():

function push(arr, ...elements) {
  for (let i = 0; i < elements.length; i++) {
    arr[arr.length] = elements[i];
  }
  return arr.length;
}

pop():

function pop(arr) {
  if (arr.length === 0) {
    return undefined;
  }
  const lastElement = arr[arr.length - 1];
  arr.length--;
  return lastElement;
}

unshift():

function unshift(arr, ...elements) {
  for (let i = arr.length - 1; i >= 0; i--) {
    arr[i + elements.length] = arr[i];
  }
  for (let i = 0; i < elements.length; i++) {
    arr[i] = elements[i];
  }
  return arr.length;
}

shift():

function shift(arr) {
  if (arr.length === 0) {
    return undefined;
  }
  const firstElement = arr[0];
  for (let i = 1; i < arr.length; i++) {
    arr[i - 1] = arr[i];
  }
  arr.length--;
  return firstElement;
}

对象

方法	参数	操作	返回值	时间复杂度	空间复杂度
Object.keys()	对象	返回一个包含对象所有可枚举属性的键的数组	包含对象键的数组	O(n)	O(n)
Object.values()	对象	返回一个包含对象所有可枚举属性的值的数组	包含对象值的数组	O(n)	O(n)
Object.entries()	对象	返回一个包含对象所有可枚举属性键值对的数组	包含对象键值对的数组	O(n)	O(n)
Object.assign()	目标对象和一个或多个源对象	将一个或多个源对象的属性复制到目标对象，并返回目标对象	目标对象	O(m)	O(1)
Object.freeze()	对象	冻结对象，使其属性不可修改	冻结后的对象	O(n)	O(1)
Object.seal()	对象	封闭对象，使其属性不可添加或删除，但可以修改	封闭后的对象	O(n)	O(1)
Object.create()	原型对象和可选的属性描述符对象	创建一个新对象，使用指定的原型对象和属性描述符对象	新创建的对象	O(1)	O(1)
Object.getPrototypeOf()	对象	返回指定对象的原型对象	对象的原型	O(1)	O(1)
Object.hasOwnProperty()	对象和属性名	判断对象自身是否具有指定的属性	布尔值	O(1)	O(1)
Object.is()	两个值	比较两个值是否严格相等	布尔值	O(1)	O(1)

示例：

Object.keys():

function keys(obj) {
  const result = [];
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      result.push(key);
    }
  }
  return result;
}

Object.values():

function values(obj) {
  const result = [];
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      result.push(obj[key]);
    }
  }
  return result;
}

Object.entries():

function entries(obj) {
  const result = [];
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      result.push([key, obj[key]]);
    }
  }
  return result;
}

Object.assign():

function assign(target, ...sources) {
  for (let i = 0; i < sources.length; i++) {
    const source = sources[i];
    for (let key in source) {
      if (source.hasOwnProperty(key)) {
        target[key] = source[key];
      }
    }
  }
  return target;
}

字符串

方法	参数	操作	返回值	时间复杂度	空间复杂度
length	无	返回字符串的长度	字符串长度	O(1)	O(1)
concat()	一个或多个字符串或值	连接多个字符串或值，并返回新的字符串	新字符串	O(n)	O(n)
indexOf()	要查找的字符串和起始搜索位置（可选）	返回指定字符串在源字符串中首次出现的位置，如果不存在则返回-1	字符串的索引或-1	O(n)	O(1)
lastIndexOf()	要查找的字符串和起始搜索位置（可选）	返回指定字符串在源字符串中最后一次出现的位置，如果不存在则返回-1	字符串的索引或-1	O(n)	O(1)
includes()	要查找的字符串和起始搜索位置（可选）	检测源字符串是否包含指定字符串	布尔值	O(n)	O(1)
slice()	起始索引和结束索引（可选）	提取源字符串中指定范围的字符并返回一个新字符串	选定的子字符串	O(k)	O(k)
substring()	起始索引和结束索引（可选）	提取源字符串中指定范围的字符并返回一个新字符串，与slice()类似但不支持负索引	选定的子字符串	O(k)	O(k)
substr()	起始索引和长度（可选）	提取源字符串中从指定索引开始的指定长度字符并返回一个新字符串	选定的子字符串	O(k)	O(k)
replace()	要替换的字符串和替换的新字符串	替换源字符串中的指定子字符串为新的字符串	替换后的新字符串	O(n)	O(n)
trim()	无	去除源字符串两端的空格和空白字符	去除两端空白的字符串	O(n)	O(n)
toUpperCase()	无	将源字符串中的所有字符转换为大写	大写的字符串	O(n)	O(n)
toLowerCase()	无	将源字符串中的所有字符转换为小写	小写的字符串	O(n)	O(n)
split()	分隔符和可选的分割次数（可选）	将源字符串按照指定的分隔符进行分割，并返回一个字符串数组	分割后的字符串数组	O(n)	O(n)

示例：

length:

function getLength(str) {
  let count = 0;
  for (let i = 0; i < str.length; i++) {
    count++;
  }
  return count;
}

concat():

function concat(str1, str2) {
  return str1 + str2;
}

indexOf():

function indexOf(str, searchValue, startIndex = 0) {
  for (let i = startIndex; i < str.length; i++) {
    if (str.slice(i, i + searchValue.length) === searchValue) {
      return i;
    }
  }
  return -1;
}

lastIndexOf():

function lastIndexOf(str, searchValue, startIndex = str.length - 1) {
  for (let i = startIndex; i >= 0; i--) {
    if (str.slice(i, i + searchValue.length) === searchValue) {
      return i;
    }
  }
  return -1;
}

includes():

function includes(str, searchValue) {
  return str.indexOf(searchValue) !== -1;
}

slice():

function slice(str, start, end) {
  let result = '';
  const length = str.length;
  if (start < 0) {
    start = Math.max(length + start, 0);
  } else {
    start = Math.min(start, length);
  }
  if (end === undefined) {
    end = length;
  } else if (end < 0) {
    end = Math.max(length + end, 0);
  } else {
    end = Math.min(end, length);
  }
  for (let i = start; i < end; i++) {
    result += str[i];
  }
  return result;
}

replace():

function replace(str, searchValue, replaceValue) {
  return str.split(searchValue).join(replaceValue);
}

trim():

function trim(str) {
  return str.replace(/^\s+|\s+$/g, '');
}

toUpperCase():

function toUpperCase(str) {
  let result = '';
  for (let i = 0; i < str.length; i++) {
    const charCode = str.charCodeAt(i);
    if (charCode >= 97 && charCode <= 122) {
      result += String.fromCharCode(charCode - 32);
    } else {
      result += str[i];
    }
  }
  return result;
}

toLowerCase():

function toLowerCase(str) {
  let result = '';
  for (let i = 0; i < str.length; i++) {
    const charCode = str.charCodeAt(i);
    if (charCode >= 65 && charCode <= 90) {
      result += String.fromCharCode(charCode + 32);
    } else {
      result += str[i];
    }
  }
  return result;
}

split():

function split(str, separator, limit) {
  const result = [];
  let start = 0;
  let count = 0;
  for (let i = 0; i < str.length; i++) {
    if (separator === '') {
      result.push(str[i]);
      count++;
    } else if (str.slice(i, i + separator.length) === separator) {
      result.push(str.slice(start, i));
      start = i + separator.length;
      count++;
      if (limit && count >= limit) {
        break;
      }
    }
  }
  result.push(str.slice(start));
  return result;
}

posted on 2023-07-13 20:15 双友阅读(45) 评论(0) 编辑收藏举报

刷新页面返回顶部

前端操作方法

数组

对象

字符串

导航

公告