记录--九个超级好用的 Javascript 技巧

Posted 2023-05-22 林恒

这里给大家分享我在网上总结出来的一些知识，希望对大家有所帮助

前言

在实际的开发工作过程中，积累了一些常见又超级好用的 Javascript 技巧和代码片段，包括整理的其他大神的 JS 使用技巧，今天筛选了 9 个，以供大家参考。

1、动态加载 JS 文件

在一些特殊的场景下，特别是一些库和框架的开发中，我们有时会去动态的加载 JS 文件并执行，下面是利用 Promise 进行了简单的封装。

function loadJS(files, done) 
  // 获取head标签
  const head = document.getElementsByTagName(\'head\')[0];
  Promise.all(files.map(file => 
    return new Promise(resolve => 
      // 创建script标签并添加到head
      const s = document.createElement(\'script\');
      s.type = "text/javascript";
      s.async = true;
      s.src = file;
      // 监听load事件，如果加载完成则resolve
      s.addEventListener(\'load\', (e) => resolve(), false);
      head.appendChild(s);
    );
  )).then(done);  // 所有均完成，执行用户的回调事件


loadJS(["test1.js", "test2.js"], () => 
  // 用户的回调逻辑
);

上面代码核心有两点，一是利用 Promise 处理异步的逻辑，而是利用 script 标签进行 js 的加载并执行。

2、实现模板引擎

下面示例用了极少的代码实现了动态的模板渲染引擎，不仅支持普通的动态变量的替换，还支持包含 for 循环，if 判断等的动态的 JS 语法逻辑，具体实现逻辑在笔者另外一篇文章《面试官问：你能手写一个模版引擎吗？》做了非常详详尽的说明，感兴趣的小伙伴可自行阅读。

// 这是包含了js代码的动态模板
var template =
\'My avorite sports:\' +
\'<%if(this.showSports) %>\' +
    \'<% for(var index in this.sports)    %>\' +
    \'<a><%this.sports[index]%></a>\' +
    \'<%%>\' +
\'<% else %>\' +
    \'<p>none</p>\' +
\'<%%>\';
// 这是我们要拼接的函数字符串
const code = `with(obj) 
  var r=[];
  r.push("My avorite sports:");
  if(this.showSports) 
    for(var index in this.sports) 
      r.push("<a>");
      r.push(this.sports[index]);
      r.push("</a>");
    
   else 
    r.push("<span>none</span>");
  
  return r.join("");
`
// 动态渲染的数据
const options = 
  sports: ["swimming", "basketball", "football"],
  showSports: true

// 构建可行的函数并传入参数，改变函数执行时this的指向
result = new Function("obj", code).apply(options, [options]);
console.log(result);

3、利用 reduce 进行数据结构的转换

有时候前端需要对后端传来的数据进行转换，以适配前端的业务逻辑，或者对组件的数据格式进行转换再传给后端进行处理，而 reduce 是一个非常强大的工具。

const arr = [
     classId: "1", name: "张三", age: 16 ,
     classId: "1", name: "李四", age: 15 ,
     classId: "2", name: "王五", age: 16 ,
     classId: "3", name: "赵六", age: 15 ,
     classId: "2", name: "孔七", age: 16 
];

groupArrayByKey(arr, "classId");

function groupArrayByKey(arr = [], key) 
    return arr.reduce((t, v) => (!t[v[key]] && (t[v[key]] = []), t[v[key]].push(v), t), )

很多很复杂的逻辑如果用 reduce 去处理，都非常的简洁。

4、添加默认值

有时候一个方法需要用户传入一个参数，通常情况下我们有两种处理方式，如果用户不传，我们通常会给一个默认值，亦或是用户必须要传一个参数，不传直接抛错。

function double() 
    return value *2


// 不传的话给一个默认值0
function double(value = 0) 
    return value * 2


// 用户必须要传一个参数，不传参数就抛出一个错误

const required = () => 
    throw new Error("This function requires one parameter.")

function double(value = required()) 
    return value * 2


double(3) // 6
double() // throw Error

5、函数只执行一次

有些情况下我们有一些特殊的场景，某一个函数只允许执行一次，或者绑定的某一个方法只允许执行一次。

export function once (fn) 
  // 利用闭包判断函数是否执行过
  let called = false
  return function () 
    if (!called) 
      called = true
      fn.apply(this, arguments)
    
  

6、实现 Curring

JavaScript 的柯里化是指将接受多个参数的函数转换为一系列只接受一个参数的函数的过程。这样可以更加灵活地使用函数，减少重复代码，并增加代码的可读性。

function curry(fn) 
  return function curried(...args) 
    if (args.length >= fn.length) 
      return fn.apply(this, args);
     else 
      return function(...args2) 
        return curried.apply(this, args.concat(args2));
      ;
    
  ;


function add(x, y) 
  return x + y;


const curriedAdd = curry(add);

console.log(curriedAdd(1)(2)); // 输出 3
console.log(curriedAdd(1, 2)); // 输出 3

通过柯里化，我们可以将一些常见的功能模块化，例如验证、缓存等等。这样可以提高代码的可维护性和可读性，减少出错的机会。

7、实现单例模式

JavaScript 的单例模式是一种常用的设计模式，它可以确保一个类只有一个实例，并提供对该实例的全局访问点，在 JS 中有广泛的应用场景，如购物车，缓存对象，全局的状态管理等等。

let cache;
class A 
  // ...


function getInstance() 
  if (cache) return cache;
  return cache = new A();


const x = getInstance();
const y = getInstance();

console.log(x === y); // true

8、实现 CommonJs 规范

CommonJS 规范的核心思想是将每个文件都看作一个模块，每个模块都有自己的作用域，其中的变量、函数和对象都是私有的，不能被外部访问。要访问模块中的数据，必须通过导出（exports）和导入（require）的方式。

// id：完整的文件名
const path = require(\'path\');
const fs = require(\'fs\');
function Module(id)
    // 用来唯一标识模块
    this.id = id;
    // 用来导出模块的属性和方法
    this.exports = ;


function myRequire(filePath) 
    // 直接调用Module的静态方法进行文件的加载
    return Module._load(filePath);


Module._cache = ;
Module._load = function(filePath) 
    // 首先通过用户传入的filePath寻址文件的绝对路径
    // 因为再CommnJS中，模块的唯一标识是文件的绝对路径
    const realPath = Module._resoleveFilename(filePath);
    // 缓存优先，如果缓存中存在即直接返回模块的exports属性
    let cacheModule = Module._cache[realPath];
    if(cacheModule) return cacheModule.exports;
    // 如果第一次加载，需要new一个模块，参数是文件的绝对路径
    let module = new Module(realPath);
    // 调用模块的load方法去编译模块
    module.load(realPath);
    return module.exports;


// node文件暂不讨论
Module._extensions = 
   // 对js文件处理
  ".js": handleJS,
  // 对json文件处理
  ".json": handleJSON


function handleJSON(module) 
 // 如果是json文件，直接用fs.readFileSync进行读取，
 // 然后用JSON.parse进行转化，直接返回即可
  const json = fs.readFileSync(module.id, \'utf-8\')
  module.exports = JSON.parse(json)


function handleJS(module) 
  const js = fs.readFileSync(module.id, \'utf-8\')
  let fn = new Function(\'exports\', \'myRequire\', \'module\', \'__filename\', \'__dirname\', js)
  let exports = module.exports;
  // 组装后的函数直接执行即可
  fn.call(exports, exports, myRequire, module,module.id,path.dirname(module.id))


Module._resolveFilename = function (filePath) 
  // 拼接绝对路径，然后去查找，存在即返回
  let absPath = path.resolve(__dirname, filePath);
  let exists = fs.existsSync(absPath);
  if (exists) return absPath;
  // 如果不存在，依次拼接.js,.json,.node进行尝试
  let keys = Object.keys(Module._extensions);
  for (let i = 0; i < keys.length; i++) 
    let currentPath = absPath + keys[i];
    if (fs.existsSync(currentPath)) return currentPath;
  
;

Module.prototype.load = function(realPath) 
  // 获取文件扩展名，交由相对应的方法进行处理
  let extname = path.extname(realPath)
  Module._extensions[extname](this)

上面对 CommonJs 规范进行了简单的实现，核心解决了作用域的隔离，并提供了 Myrequire 方法进行方法和属性的加载，对于上面的实现，笔者专门有一篇文章《38 行代码带你实现 CommonJS 规范》进行了详细的说明，感兴趣的小伙伴可自行阅读。

9、递归获取对象属性

如果让我挑选一个用的最广泛的设计模式，我会选观察者模式，如果让我挑一个我所遇到的最多的算法思维，那肯定是递归，递归通过将原始问题分割为结构相同的子问题，然后依次解决这些子问题，组合子问题的结果最终获得原问题的答案。

const user = 
  info: 
    name: "张三",
    address:  home: "Shaanxi", company: "Xian" ,
  ,
;

// obj是获取属性的对象，path是路径，fallback是默认值
function get(obj, path, fallback) 
  const parts = path.split(".");
  const key = parts.shift();
  if (typeof obj[key] !== "undefined") 
    return parts.length > 0 ?
      get(obj[key], parts.join("."), fallback) :
      obj[key];
  
  // 如果没有找到key返回fallback
  return fallback;


console.log(get(user, "info.name")); // 张三
console.log(get(user, "info.address.home")); // Shaanxi
console.log(get(user, "info.address.company")); // Xian
console.log(get(user, "info.address.abc", "fallback")); // fallback

本文转载于:

https://juejin.cn/post/7223938976158957624

如果对您有所帮助，欢迎您点个关注，我会定时更新技术文档，大家一起讨论学习，一起进步。

 

eclipse调试java程序的九个技巧

转：http://www.cnblogs.com/lingiu/p/3802391.html

 

九个技巧：

1. 逻辑结构
2. 条件debug
3. 异常断点
4. 单步过滤
5. 跳到帧
6. Inspect
7. expressions
8. display
9. 远程debug

 

　　最早开始用eclipse的debug的时候，只会F5 F6 F7 F8，甚至F7都不是很搞的明白是怎么用的，那时候资浅，碰不到需要复杂debug的代码，慢慢工作深入了，场景碰多了，就需要各种debug技巧来提升定位bug效率，以前找人帮忙排查问题，看他开各种窗口debug各种溜甚是羡慕嫉妒恨，慢慢久病成医自己也用溜了eclipse的一些主要的debug技巧。稍作整理分享出来。

　　F5678这四个基本技能就略过不说了，但是最基本的技能能解决90%问题，所以虽然略过不说 ，但是必须用的很溜，相信园友达人们这四个肯定比我用的溜的多。

1. 逻辑结构

逻辑结构主要用来展示map之类的collection数据结构存储的值的，它只展示存储值的逻辑部分，而屏蔽了数据结构详细的内部结构，更方便我们查看map之类collection结构里存储的值，推荐使用。

这个按钮就是展示逻辑结构的按钮，下面两个图，上图是不展示逻辑结构，下图是展示逻辑结构，很明显，下图的结构可读性更强，可以专注于debug的变量。

 

2. 条件debug

条件debug用在需要满足某种条件才会触发断点的场景，比如只有id是12345这条记录会有问题，那就当id等于12345时才触发断点，其他都放过。

右击断点选择断点属性，就能看到这样一个配置框，右边的文本区块可以填写条件代码，比如id==12345，由于每次都要做这个判断，如果循环数很大的话，还是有点点慢的，你可以去上个厕所接个水啊什么的，还是很方便的。

 

 

3. 异常断点

异常断点只要用在debug某种异常的时候，可以配置当这个异常出现后才触发断点，不需要debug去寻找异常。

点击这个红圈就能弹出异常断点的窗口，会列出你系统里的所有异常类，然后选择需要断点的异常就OK。

 

 

4. 单步过滤

单步过滤的场景是我们在使用F5来跟到某个方法内部的时候，经常会跟到一些我们确定不需要看的方法内部。

this.getTradeDetail(uid, itemStr.subString(0,5))

比如这行代码，想F5进入getTradeDetail内部，会首先执行itemStr.subString方法，会先进入subString方法，而这方法是jdk的String方法，确定没问题，不需要关心，单步过滤就是跳过这些我们想忽略的方法直接到目标方法内部的一种debug技巧。

在Window > PreferencesJava > Debug > Step Filtering 设置过滤器, 可以选择需要过滤掉的包和类。同时要确保你在debug视图中启用了单步过滤，如下图。这样在使用单步调试的时候，就会使用到这个过滤功能。

上图是过滤器配置，典型的就是把jdk的一些类和包配置过滤。下图是要在debug时候开启单步过滤，否则不生效。

 

 

 

 

5. 跳到帧

跳到帧是一种重入技巧，在debug时，eclipse可以直接跳到调用栈中指定的任意桢，并且使JVM在此处重新运行。这使你可以重新运行你的部分代码，而不需要为了调试之前的代码而重新来一次。

要注意的是：已经被修改的变量不会被重置，它们会保留当时的值。

使用方式：选择调用栈中的一桢，点击按钮“跳到桢”

6. Inspect

inspect用来查看某个表达式的之，对于变量值debug很容查看，但是对于一个表达式的值就不容易查看，还是这句：

this.getTradeDetail(uid, itemStr.subString(0,5))

想看getTradeDetail的值，就没法想看变量值一样（虽然这个很有可能是赋值给一个变量...），要看这种表达式值，就需要inspect，具体做法是选中这行表达式，然后右击->inspect,或者更方便的快捷键组合：ctrl+shift+i,会弹出如下的展示表达式结果的框：

7. expressions

expressions窗口也是用来看变量或者表达式的值的，在windows->show viewz中打开expression窗口，然后在里面添加你想观察的表达式，比如还是这句：

this.getTradeDetail(uid, itemStr.subString(0,5))

然后debug的时候，就能看到被添加的表达式结果了，另外也能根据需要改value的值。

8. display

display也是用来观察和修改变量or表达式的，这个应该用的人比较多，在windows->show viewz中打开display窗口，可以在display窗口里写表达式，然后右击选择display运行查看结果或者ctrl+shift+D快捷键组合，表达式可以是程序中一行代码或者你自己写的一个赋值语句来改变变量值之类的。

 

9. 远程debug

远程debug可以用来调试远程服务器上的代码，保证你本地代码和远程部署的代码是一致，就可以通过这种方式debug服务器代码，这个是java web开发的一大利器，否则定位服务器问题简直是灾难。

远程debug需要服务器端启动jvm的时候做一些开启和端口的配置，具体的配置网上很多，搜一下即可。然后在本地的debug configuration中双击添加一个remote java application，填写远程主机的host和配置的debug端口，就可以开始debug了，如下图：