JavaScript的工具函数

已于 2022-12-29 14:47:39 修改
阅读量182 收藏
点赞数
文章标签： javascript 前端 vue.js
于 2022-09-20 10:51:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49884775/article/details/126948741
版权

工具函数

罗马数字和整数互换

export const intToRomanData = {
    1: 'I',
    5: 'V',
    10: 'X',
    50: 'L',
    100: 'C',
    500: 'D',
    1000: 'M'
}
export const romanToIntData = {
    'I': 1,
    'V': 5,
    'X': 10,
    'L': 50,
    'C': 100,
    'D': 500,
    'M': 1000
}
/**
 * 罗马数字和整数互换
 * @param {*} v 
 */
export const intInterconversionRoman = (v)=>{
    let result = 0
    let index = 0
    if(typeof(v)==='string'){
        const len = v.length
        while (index < len) {
            let current = romanToIntData[v[index]]
            result += current
            if (index > 0) {
                let before = romanToIntData[v[index - 1]]
                if ((current === 5 || current === 10) && before === 1) {
                    result -= 2
                }
                if ((current === 50 || current === 100) && before === 10) {
                    result -= 20
                }
                if ((current === 500 || current === 1000) && before === 100) {
                    result -= 200
                }
            }
            index++
        }
    }else if(typeof(v)==='number'){
        index = 1
        result = ''
        while (v) {
            let current = v % 10
            if (current < 4) {
                result = intToRomanData[index].repeat(current) + result
            } else if (current === 4) {
                result = intToRomanData[index] + intToRomanData[index * 5] + result
            } else if (current > 4 && current < 9) {
                result = intToRomanData[index * 5] + intToRomanData[index].repeat(current - 5) + result
            } else {
                result = intToRomanData[index] + intToRomanData[index * 10] + result
            }
            index *= 10
            v = Math.trunc(v / 10)
        }
    }else{
        return new Error('传参类型错误')
    }
    return result
}

格式化时间

/**
 * 格式化时间
 * @param {*} fmt 
 * @param {*} dateString 
 * @returns 
 */
export const fmtDate = function (fmt, dateString) {

    const date = new Date(dateString);

    let ret;
    const opt = {
        "Y+": date.getFullYear().toString(), // 年
        "m+": (date.getMonth() + 1).toString(), // 月
        "d+": date.getDate().toString(), // 日
        "H+": date.getHours().toString(), // 时
        "M+": date.getMinutes().toString(), // 分
        "S+": date.getSeconds().toString() // 秒
        // 有其他格式化字符需求可以继续添加，必须转化成字符串
    };
    for (let k in opt) {
        ret = new RegExp("(" + k + ")").exec(fmt);
        if (ret) {
            fmt = fmt.replace(ret[1], (ret[1].length == 1) ? (opt[k]) : (opt[k].padStart(ret[1].length, "0")))
        };
    };
    return fmt;
}

浏览器刷新提示

/**
 * 浏览器刷新提示框
 * @param {vue实例} that
 * @param {路由} route 
 */
export const beforeUnloadFunc = (that, route) => {
    window.onbeforeunload = function (e) {
        if (that.$route.fullPath == route) { // 注意这里要替换成自己的当前页面的路由
            e = e || window.event;
            // 兼容IE8和Firefox 4之前的版本
            if (e) {
                e.returnValue = '关闭提示';
            }
            // Chrome, Safari, Firefox 4+, Opera 12+ , IE 9+
            return '关闭提示';
        } else {
            window.onbeforeunload = null
        }
    };
}

深拷贝

/**
 * 深拷贝
 * @param {*} source 
 * @returns 
 */
export const deepClone = (source) => {

    // if(obj instanceof null) return null;

    // if(obj instanceof Date) return new Date(Obj);

    // if(obj instanceof RegExp) return new RegExp(obj);

    if (!source) throw new Error('error arguments', 'deepClone')

    if (typeof source !== 'object') return source;

    const targetObj = source.constructor === Array ? [] : {}
    Object.keys(source).forEach(keys => {
        if (source[keys] && typeof source[keys] === 'object') {
            targetObj[keys] = deepClone(source[keys])
        } else {
            targetObj[keys] = source[keys]
        }
    })
    return targetObj

}

前端简单搜索

/**
 * 前端搜索
 * @param {数组} arr 
 * @param {搜索关键字符串} search 
 * @param {数组对比字符串} str 
 * @returns 
 */
export const strFilterArr = (arr, search, reg) => {
    //  const REG = new RegExp(this.title, "i");
    const newArr = []
    arr.filter((item) => {
        if (item[reg].includes(search)) {
            newArr.push(item);
        }
    });
    return newArr
}

一二级cookie操作

// 获取cookie
export const getCookie = (name) => {
    name += '='
    let cookie = document.cookie.split(';')
    for (let i = 0; i < cookie.length; i++) {
        let c = cookie[i].trim();
        if (c.indexOf(name) == 0) {
            return c.substring(name.length, c.length);
        }
    }
    return "";
}
 //清空cookie
export const clearCookie = () => {
   
    const keys = document.cookie.match(/[^ =;]+(?=\=)/g);
    if (keys) {
        for (let i = keys.length; i--;) {
            document.cookie = keys[i] + '=0;path=/;expires=' + new Date(0).toUTCString(); //清除当前域名下的,例如：m.kevis.com
            document.cookie = keys[i] + '=0;path=/;domain=' + document.domain + ';expires=' + new Date(0).toUTCString(); //清除当前域名下的，例如 .m.xxx.com
            document.cookie = keys[i] + '=0;path=/;domain=kevis.com;expires=' + new Date(0).toUTCString(); //清除一级域名下的或指定的，例如 .xx.com
        }
    }

}

判断浏览器


export const browserName = () => {
// 判断浏览器
    if (window.ActiveXObject) {
        return 'ie'
    } else if (document.getBoxObjectFor) { //只有火狐有
        return 'firefox'
    } else if (window.MessageEvent && !document.getBoxObjectFor) {
        return 'chrome'
    } else if (window.opera) {
        return 'opera'
    } else if (window.openDatebase) {
        return 'safair'
    } else {
        return 'no'
    }
}

中文转首字母

/**
 * 中文转首字母
 */
import https://download.csdn.net/download/weixin_49884775/87352808
export const PinYin = class {
  chineseToPinYin(l1) {
    let l2 = l1.length
    let I1 = ''
    let reg = new RegExp('[a-zA-Z0-9]')
    for (let i = 0; i < l2; i++) {
      let val = l1.substr(i, 1)
      let name = this.arraySearch(val)
      if (reg.test(val)) {
        I1 += val
      } else if (name !== false) {
        I1 += name
      }
    }
    I1 = I1.replace(/ /g, '-')
    while (I1.indexOf('--') > 0) {
      I1 = I1.replace('--', '-')
    }
    return I1[0].toUpperCase()
  }

  arraySearch(l1) {
    for (let name in pinyin) {
      if (pinyin[name].indexOf(l1) !== -1) {
        return this.ucfirst(name)
      }
    }
    return false
  }
  ucfirst(l1) {
    if (l1.length > 0) {
      let first = l1.substr(0, 1).toUpperCase()
      let spare = l1.substr(1, l1.length)
      return first + spare
    }
  }
}

计算数组重复次数

/**
 * 计算数组重复次数
 */
 export const countOccurrences = (arr, val) =>
 arr.reduce((a, v) => (v === val ? a + 1 : a), 0)

base64 blod file互换

/**
 * 将base64转换为blob
 * @param {*} dataurl 
 * @returns 
 */
export const dataURLtoBlob = function (dataurl) {
    let arr = dataurl.split(',')
    let mime = arr[0].match(/:(.*?);/)[1]
    let bstr = atob(arr[1])
    let n = bstr.length
    let u8arr = new Uint8Array(n)
    while (n--) {
        u8arr[n] = bstr.charCodeAt(n);
    }
    return new Blob([u8arr], {
        type: mime
    });
}
/**
 * 将blob转换为file
 * @param {*} theBlob 
 * @returns 
 */
export const blobToFile = function (theBlob, fileName = 'huxingtu.png') {
    theBlob.lastModifiedDate = new Date();
    theBlob.name = fileName;
    return theBlob;
}
/**
 * 将base64转换为file
 * @param {*} dataurl
 * @returns 
 */
export const dataURItoFile = function (dataurl, name = 'huxing') {
    let arr = dataurl.split(',')
    let mime = arr[0].match(/:(.*?);/)[1]
    let suffix = mime.split('/')[1];
    let bstr = atob(arr[1])
    let n = bstr.length
    let u8arr = new Uint8Array(n)
    while (n--) {
        u8arr[n] = bstr.charCodeAt(n)
    }
    return new File([u8arr], `${name}.${suffix}`, {
        type: mime,
    })
}

localstore有效期

/*
* localstore添加有效期
*/
export const selfStorage = () => {
  // 存值函数
  Storage.prototype.setCanExpireLocal = (key, value, expire) => {
    // 接收三个参数：键、值、有效分钟数
    // 判断传入的有效期是否为数值或有效
    // isNaN是js的内置函数，用于判断一个值是否为NaN（非数值），
    // 非数值返回true，数值返回false
    if (isNaN(expire) || expire < 1) {
      throw new Error('有效期应为一个有效数值')
    }
    // 60000 是1分钟时间的毫秒数，
    let time = expire * 60000
    let obj = {
      data: value, //存储值
      time: Date.now(), //存值时间戳
      expire: time, //过期时间
    }
    // 注意，localStorage不能直接存储对象类型，sessionStorage也一样
    // 需要先用JSON.stringify()将其转换成字符串，取值时再通过JSON.parse()转换回来
    localStorage.setItem(key, JSON.stringify(obj))
  }

  // 取值函数
  // 接收一个参数，存值的键										
  Storage.prototype.getCanExpireLocal = key => {
    let val = localStorage.getItem(key)
    // 如果没有值就直接返回null
    if (!val) return val
    // 存的时候转换成了字符串，现在转回来
    val = JSON.parse(val)
    // 存值时间戳 +  有效时间 = 过期时间戳
    // 如果当前时间戳大于过期时间戳说明过期了，删除值并返回提示
    if (Date.now() > val.time + val.expire) {
      localStorage.removeItem(key)
      return null
    }
    return val.data
  }
}

自定义指令

复制

/**使用 <el-button class="borra" type="primary" v-click-copy="aaa">复制</el-button>*/
import { Message } from 'element-ui'


// 处理传过来的参数
const handleParams = (el,value) => {
  if(Object.prototype.toString.call(value) === '[object Object]'){
    el.$value = value.value
    el.$offset = value.offset
  }else{
    el.$value = value
    el.$offset = 20
  }
}

export default {
  bind(el, { value }) {
    console.log('copy value', value.value)
    handleParams(el,value);
    el.clickHandler = () => {
      if (!el.$value) {
        console.log('无复制内容')
        return
      }
      let input = document.createElement('input')
      input.value = el.$value
      input.readOnly = 'readOnly'
      input.style.position = 'absoulte'
      input.style.zIndex = '-9999px'
      document.body.appendChild(input)
      input.select()
      let result = document.execCommand('copy')
      if (result) {
        Message({
          message: '复制成功',
          type: 'success',
          offset: el.$offset
        })
        document.body.removeChild(input)
      }
    }
    el.addEventListener('click', el.clickHandler)
  },
  componentUpdated(el, { value }) {
    handleParams(el,value);
  },
  unbind(el) {
    el.removeEventListener('click', el.clickHandler)
  }
}

懒加载

/**
 * 使用<img v-imgLazy data-src="https://a.com/图1.png" src="" alt=""  />
 * @description 图片懒加载指令
 */
function hanldeImgLoad(entries) {
  entries.forEach(v => v.isIntersecting && v.target.setAttribute('src', v.target.getAttribute('data-src')));
}

//判断元素是否在可视区域
function isViewport(el) {
  const viewWidth = window.innerWidth || document.documentElement.clientWidth;
  const viewHeight = window.innerHeight || document.documentElement.clientHeight;
  let {
    top,
    left,
    right,
    bottom,
    width,
    height
  } = el.getBoundingClientRect();
  return top >= 0 && left >= 0 && right + width <= viewWidth && bottom + height <= viewHeight;
}

//threshold设置元素位于界面可视化区域的比例，0~1,1(完全位于可视化区域)
const observe = new IntersectionObserver(hanldeImgLoad, {
  threshold: 0.6
});
export default {
  bind(el) {
    observe.observe(el);
  },
  componentUpdated(el) {
    isViewport(el) && (el.src = el.getAttribute('data-src'));
  },
  unbind(el) {
    observe.unobserve(el);
  },
};

防抖

/** 使用 <el-input v-debounce-input="formItem.inputEvent"></el-input>*/
export default {
  //bind解构出value  node解构出data
  bind: (el, { value }, { data }) => {
    let awaitTime = 0
    if (!Number.isNaN(+data.attrs['debounce-second'])) {
      awaitTime = +data.attrs['debounce-second'] * 1000
    } else {
      console.error('debounce-second type is number or string digit')
    }
    // console.log("debounce-input awaitTime", awaitTime);
    el.handleInput = function(val) {
      if (el.timer) {
        clearTimeout(el.timer)
      }
      el.timer = setTimeout(() => {
        value(val)
      }, awaitTime || 500)
    }
    el.addEventListener('input', el.handleInput)
  },
  unbind: el => {
    el.timer && clearTimeout(el.timer)
    el && el.removeEventListener('input', el.handleInput)
  }
}

自动加载文件

let list = []
//directory {String} -读取文件的路径
//useSubdirectories {Boolean} -是否遍历文件的子目录
//regExp {RegExp} -匹配文件的正则
const requireDirective = require.context('.', false, /\.js$/)
//提供三个接口
//webpackContext 加载文件的接口  调用加载文件__webpack_require__再调用webpackContextResolve
//webpackContext.resolve = webpackContextResolve  根据相对路径去找到绝对路径名接口
//webpackContext.keys = function(){ } 从map取出所有的相对路径接口
console.log('requireDirective', requireDirective)
requireDirective.keys().map((fileName, i) => {
  console.log('fileName', fileName, i)
  if (!fileName.includes('index.js')) {
    const directiveConfig = requireDirective(fileName)
    list.push({ fn: directiveConfig, name: fileName.slice(2).slice(0, -3) })
    console.log('directiveConfig', directiveConfig)
  }
})
export default {
  install(Vue) {
    console.log('install', list)
    list.map(item => {
      Vue.directive(item.name, item.fn.default || item.fn)
    })
    // Vue.directive('limit-input-number', LimitInputNumber)
    // Vue.directive('debounce-input', debounceInput)
  }
}

加密

import jsencrypt from 'jsencrypt';

function rsaUtil(data) {
    let Je = new jsencrypt({
        default_key_size: 1024
    })
    Je.setPublicKey('aaaaaa')
    if (data instanceof Object) {
        data = JSON.stringify(data);
    }
    return Je.encrypt(data);
}
export default rsaUtil;

水印

export default function __canvasWM({
  // 使用 ES6 的函数默认值方式设置参数的默认取值
  container = document.body,
  width = '100vw',
  height = '120%',
  textAlign = 'center',
  textBaseline = 'middle',
  font = "800 15px Microsoft Yahei",
  fillStyle = 'rgba(184, 184, 184, 0.5)',
  content = '请勿外传',
  rotate = '60',
  zIndex = 1000
} = {}) {
  const args = arguments[0];
  console.log(args);
  const canvas = document.createElement('canvas');
  canvas.setAttribute('width', width);
  canvas.setAttribute('height', height);
  const ctx = canvas.getContext("2d");
  ctx.textAlign = textAlign;
  // ctx.textBaseline = textBaseline;
  ctx.font = font;
  ctx.fillStyle = fillStyle;
  ctx.rotate(Math.PI / 360 * rotate);
  ctx.fillText(content, parseFloat(width) / 2, parseFloat(height) / 15,80);
  const base64Url = canvas.toDataURL();
  const __wm = document.querySelector('.__wm');
  const watermarkDiv = __wm || document.createElement("div");
  const styleStr = `
    position:absolute;
    top:1rem;
    left:200px;
    width:calc(100% - 200px);
    height:calc(100% - 1rem);
    z-index:${zIndex};
    pointer-events:none;
    background-image:url('${base64Url}')`;
  watermarkDiv.setAttribute('style', styleStr);
  watermarkDiv.classList.add('__wm');
  if (!__wm) {
    container.style.position = 'relative';
    container.insertBefore(watermarkDiv, container.firstChild);
  }
  const MutationObserver = window.MutationObserver || window.WebKitMutationObserver;
  if (MutationObserver) {
    let mo = new MutationObserver(function () {
      const __wm = document.querySelector('.__wm');
      // 只在__wm元素变动才重新调用 __canvasWM
      if ((__wm && __wm.getAttribute('style') !== styleStr) || !__wm) {
        // 避免一直触发
        mo.disconnect();
        mo = null;
      __canvasWM(JSON.parse(JSON.stringify(args)));
      }
    });

    mo.observe(container, {
      attributes: true,
      subtree: true,
      childList: true
    })
  }
}

自适应

export const fun = function (doc, win) {
  const docEl = doc.documentElement
  const resizeEvt = 'orientationchange' in window ? 'orientationchange' : 'resize'
  const recalc = function () {
    const clientWidth = docEl.clientWidth;
    if (!clientWidth) return;

    //这里是假设在1920px宽度设计稿的情况下，1rem = 20px；
    //可以根据实际需要修改
    docEl.style.fontSize = 100 * (clientWidth / 1920) + 'px';
    // docEl.style.fontSize = 100 * (clientWidth / 1440) + 'px';
  };
  if (!doc.addEventListener) return;
  win.addEventListener(resizeEvt, recalc, false);
  doc.addEventListener('DOMContentLoaded', recalc, false);
}
weixin_49884775
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
JavaScript 函数定义
Python老吕的博客
06-01 945
在JavaScript中，函数是一段可以重复使用的代码块，它执行特定的任务。函数可以接受输入（称为参数）并可能返回输出（称为返回值）。// 函数体// 执行特定任务的代码// 可选，返回函数执行的结果JavaScript中的函数是强大而灵活的工具，它们不仅可以执行特定的任务，还可以作为一等公民参与各种操作。通过了解函数的基本语法、作用域、闭包以及现代JavaScript中引入的箭头函数和异步函数等特性，我们可以写出更加高效、可维护的代码。
两个比较有用的Javascript工具函数代码
10-29
下面我的base.js中的extend函数可以允许用json格式赋值属性甚至是函数句柄
2022年第三次面试，含泪整理万字面试题。
vcdddd的博客
08-18 821
涵盖了面试常问必问的题目，vue2，vue3三件套等等。
防抖函数JavaScript
m0_51658494的博客
04-11 6647
防抖函数 先总结下对防抖函数的理解： 防抖函数就是防止用户进行一些点击事件或者输入文字时，对应绑定的事件发生多次 比如我在点击后发送ajax请求，但是我联系按了两次，然后请求就发送了两次 或者在输入框中打字时候，还没有结束打字就已经发送了请求 （当然有些搜索框正需要这样的功能，但是也是需要限制，肯定也得等完整的字符输入才显示推荐） 防抖函数具体实现： 就是用一个函数把原本要执行的事件函数包裹起来，利用setTimeout函数来规定执行的时机，同时把原本绑定的事件函数获得的参数全部给这个函数，因为会涉及到t
JavaScript实现Sleep函数
欢迎来到我的博客！我是一名全栈开发工程师，主攻前端开发。希望通过我的博客，能够与大家共同学习和成长。感谢您的关注和支持！
12-23 2171
在异步编程领域，选择合适的工具对于编写高效、可维护的代码至关重要。对于简单的延迟操作，setTimeout提供了直接且易于理解的解决方案。然而，当涉及到更复杂的异步流程，如顺序执行或错误处理时，Promise和async/await则成为了更强大的工具。尽管它们可能需要更多的学习和理解，但它们提供了更加结构化和可读的代码，从而提高了代码质量和开发效率。因此，根据具体需求和场景，选择最合适的异步处理方法对于成为一名高效的开发者至关重要。
【JavaScript】 函数 function
小数点儿_
11-22 2449
也就是说，传入函数的原始值的地址，因此在函数内部修改参数，将会影响到原始值。函数参数不是必需的，JavaScript 允许省略参数，但是，没有办法只省略靠前的参数，而保留靠后的参数。只要闭包没有被垃圾回收机制清除，外层函数提供的运行环境也不会被清除，它的内部变量就始终保存着当前值，供闭包读取。它的作用域与变量一样，就是其声明时所在的作用域，与其运行时所在的作用域无关。如果函数内部修改的，不是参数对象的某个属性，而是替换掉整个参数，这时不会影响到原始值。所以，闭包可以看作是函数内部作用域的一个接口。
JavaScript函数的命名方式
zhzijun的博客
10-08 4941
函数的命名方式 JavaScript代码服用单位是函数，函数可以包含一段可执行代码，也可以接受调用者传入的参数。JavaScript定义函数主要有以下三种方式： 第一种方式：命名函数 <script> function 函数名(参数列表){//function声明函数的关键字 要执行的语句块; } function myAge(age) { document.write('我的年龄是' + age)//我的年龄是19 }
Javascript 嵌套函数 - 递归函数 - 内置函数详解
licun110的博客
04-28 1037
在了解了函数的定义和函数调用外，下面我们来介绍一下JavaScript中几种特殊的函数。下面详细给大家讲解一下这3中函数调用方式。
javascript常用函数大全
热门推荐
极客神殿
10-24 1万+
javascript函数一共可分为五类： •常规函数 •数组函数 •日期函数 •数学函数 •字符串函数 1.常规函数 javascript常规函数包括以下9个函数： (1)alert函数：显示一个警告对话框，包括一个OK按钮。 (2)confirm函数：显示一个确认对话框，包括OK、Cancel按钮。 (3)escape函数：将字符转换成Unicode码。 (4)eval函数：计算表达式的结果。 ...
最常用的 9 个JavaScript 函数与示例
BASK2311的博客
10-21 1165
您可以在日常使用中找到许多其他重要功能，但这些是我最常用的 9 个 JavaScript 功能。作为用途最广泛、用途最广泛的编程语言之一，JavaScript 有着悠久的历史和光明的未来。在本文中，我们将通过示例探讨最常用的 9 个 JavaScript 函数。在 JavaScript 中使用函数有很多优点。首先，如果你有很多代码需要重用，把它放在一个函数中可以很容易地在你需要的时候再次调用它。其次，使用函数可以通过将代码分解成更小的部分来帮助您提高代码的可读性。
typescript中引用JavaScript函数
qq_34633194的博客
08-22 1261
ts里引入js，ts使用js
MyUtils:常用JavaScript工具函数
03-20
"MyUtils"是一个集大成者，它包含了众多在日常开发中可能会用到的JavaScript工具函数，旨在提供便利、高效的支持。本文将详细介绍MyUtils库中的主要功能和应用场景。 一、数组处理 MyUtils库中的数组处理功能强大，...
JavaScript常用工具函数大全
10-15
主要介绍了JavaScript常用工具函数,汇总整理了各种JavaScript常用工具函数,包括获取、判断、转换、设置等相关功能函数的定义与使用方法,需要的朋友可以参考下
javaScript常用工具函数
08-05
工作积累总结
JavaScript工具类函数库
07-09
本资源是一个精心编写的JavaScript工具类函数库，包含了多种实用的日期处理、数值计算、字符串操作等工具函数。它提供了如日期格式化、天数判断、数组处理等功能，适用于前端开发中的各种场景。函数库采用ES6模块化...
Webkit简介以及工作流程
读心悦
07-10 311
WebKit是一个开源的浏览器引擎，最初由苹果公司基于KHTML（K Desktop Environment的HTML渲染引擎）开发，并广泛应用于Safari浏览器。随着时间的推移，WebKit也被其他多款浏览器和应用所采用，成为Web技术生态中的重要一员。WebKit的核心功能包括解析HTML、CSS、JavaScript等网页内容，并将其渲染为可视化的网页页面。它主要由WebCore（负责HTML解析、CSS样式计算和布局）和JavaScriptCore（负责JavaScript解释执行）两大部分组成。
vue引入sm-crypto通过sm4对文件进行加解密，用户输入密码
最新发布
cc1314_工作、学习有感
07-12 192
通过sm4对文件进行加解密，用户输入密码
vue2 、 vue3首屏优化，减少白屏时间
m0_56104994的博客
07-09 309
vue2、vue3首屏优化,减少白屏时间
前端 JS 经典：迭代器
weixin_64684095的博客
07-12 166
如果在最后一个值返回后再调用 next()方法，那么返回的对象中属性 done 的值为 true，属性 value 则包含迭代器最终返回的值（如果没有相关数据则返回 undefined）。可迭代对象具有 Symbol.iterator 属性，通过指定的函数可以返回一个作用于附属对象的迭代器。JavaScript 中有一些内置的可迭代对象，如数组、字符串、集合（Set）、映射（Map）等，它们都具有默认的迭代器。在 JavaScript 中，迭代器是一个对象，它定义了一个序列，并在终止时可能返回一个返回值。
cgcs2000转wgs84的javascript工具函数
05-27
以下是一个使用JavaScript语言编写的cgcs2000转wgs84的工具函数： ```javascript function gcj02_to_wgs84(lng, lat) { var a = 6378245.0; var ee = 0.00669342162296594323; var dlat = transformLat(lng - ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值