最佳5隐藏的Java技巧

Java脚本是当前时代的主流语言。 Typescript是具有OOPS概念的Javascript的高级版本。现在比以往任何时候都更具有类似 Node 甚至是独立的 基本上到处都是

因此，今天我将向您展示最好的五个隐藏的JavaScript技巧，每个开发人员都应该知道这些技巧。

? 有趣的JS事实： 我们都知道 typeof null which 返回 s "object" ，即使null应该是一个 primitive type.

所以这是5 隐藏的JavaScript 我发现对某些特定情况有用的功能。让’s go ??

+运算符

什么？ +运算符？我从一年级开始就知道

是的，当然，但是在这里’s not about the 算术操作员：

常量4 = 2 + 2;

1	const 四 = 2 + 2;

它还有另一个用途，可以看作是 “将给定的表达式转换为数字”, 但可能还会揭示其他有趣的用例：

即使这些结果可以通过 Number() constructor, it seems 和 feels much cleaner 与 the + 某些情况下的运算符。

？对于最后一个示例，我们将覆盖 的价值 () method 的 the 随机 object, 和 the + operator “grabs”通过将其转换为 Number

调试器语句

等一下’我只是调试自己吗？

当然可以！实际上，有很多方法可以调试JavaScript应用程序。？️

附有多种不同的方法 安慰 对象，您可以自定义大多数日志记录语句。

But one way that I found quite different 和 that’s不太了解是通过使用 调试器 声明。

对于基于浏览器的JS应用程序，它提供了一种放置断点的快捷方式，并且可以快速访问强大的开发人员工具：

正如我所说，这可能不是处理某些应用程序调试的最佳方法，但我认为对此进行演示很有趣 “hidden” 特征。

？您还可以通过传递以下内容来为节点脚本启用它 --inspect flag, 和 connecting to your session remotely. However, I suggest attaching to your IDE 调试器对于节点JS apps, it is cleaner this way.

逗号运算符

哼..什么？让我澄清一下。

我不是在说逗号 分隔器 我们看到的是将容器中的对象或元素分开 const rr = [2, 7, 4, 8]

看更多 :

Java脚本中的ES6三点是什么？为什么你应该知道呢？
在本文中，我们将讨论一个功能...

在表达中 const a = (2, 3) ，逗号运算符允许对括号中的整个表达式求值，’看一些有趣的例子：

基本上，该操作员同时执行 && and || between the left 和 right operands, because it executes both, regarding 的 their state.

？如果您仍然对它的用法感到困惑，可以这样考虑：它允许您在JavaScript需要的地方评估多个表达式。可能是渲染更优雅的代码，或者更轻松地调试。

集合对象

我对此100％确信您已经听说过

被介绍了与ES6 , 和 it’如果您熟悉Python，则基本上与您期望的对象相同’s set()

在各种情况下可能会派上用场：

？您可以在 MDN网站 ，或者您可能想自己实现它们！

航海家& Performance API’s

唐’不用担心，没有密钥或访问令牌！

实际上，这在这里有点特殊，因为这是两个 Web API 在浏览器中可用。？

Web API通常与JavaScript一起使用，尽管’总是必须如此。

看更多 :

通过3种优化方式在Angular中获取大数据
呈现大列表的可用技术概述...

我想介绍两个Web API’我已经在我的JavaScript项目中广泛使用了：

？这些只是您可以在网络上找到的众多Web API中的2个！随意地 在这里探索他们.

最后，这里是要点 可执行代码:

// 1-+运算符
const  加  = () => {
    //以简写语法获取时间戳
     安慰 .log（+  新   日期 （））;
    //布尔值到整数的转换
     安慰 .log（+  真正 ）;
     安慰 .log（+  假 ）;
    //科学计数法转换
     安慰 .log（+“ 1e8”）;
     安慰 .log（+“ 1.6e-2”）;
    //我最喜欢的随机生成
     const   随机  = {
     的价值 ：（）=>Math.floor（Math.random（）* 100），
     }; 
     安慰 .log（+  随机 ）;
     安慰 .log（+  随机 ）;
     安慰 .log（+  随机 ）;
};

// 2-调试器语句
//在浏览器中运行或使用--inspect作为节点
const  调试  = () => {
     const   bubbleSort  =（arr）=> {
         const   长度  =  rr .length;
        为（令我= 0;我<  长度 ; i++) {
            对于（令j = 0; j<长度-i-1; j  ++ ）{
                如果（arr [j]>  rr [j + 1]) {
                     调试器； 
                    [arr [j]，arr [j + 1]] = [arr [j + 1]，arr [j]];
                }
            }
        }
     返回arr; 
     }; 
     安慰 .log（bubbleSort（[8，2，19，8，4，4，5，2]））;
    // 2，2，4，5，8，8，19
};

// 3-逗号运算符
const  逗号  = () => {
    让钱= 10;
     const   研究了  =  假 ;
     const  Relax =（）=>console.log（“  放松 ”）;
     const   研究  =（）=>console.log（“  研究 ”）;
    学习过？ （money  ++ ，Relax（））：（（money / = 2），study（））;
     安慰 .log（money）; //研究5

    //循环中有多个变量
    对于（令i = 1，j = 2; i + j< 10; i++, j++) {
     安慰 .log（i，j）;
    }
    // 1 2; 2 3; 3 4; 4 5;

    //用于调试
    常量硬币= [
    {值：4，货币：“ EUR”}，
    {值：1，币种：“ USD”}，
    {值：5，币种：“ BTC”}，
     ]; 
     const  countOddCoins =（硬币）=> {
        让奇硬币= 0;
        coin.forEach（（{{value，currency}）=> {
          如果（值％2！= 0）{
            奇怪的硬币++，console.log（`$ {oddCoins}  与  $ {currency}`）;
            // 1美元
            // 2与BTC 
          }
         }）; 
        返回奇数币;
     }; 
     安慰 .log（countOddCoins（coins））; // 2
};

// 4-  组 （）对象
const  setDemo  = () => {
    //从数组中删除重复项  
     const   rr  = [1，1，7，5，6，6，6，8，7];
     //旧方法 
    让noDup =  rr .filter（（a，b）=>arr.indexOf（a）=== b）;
     // 新方法 
     noDup  = [...  新   组 （arr）];
     安慰 .log（noDup）;
     // 1 7 5 6 8 

    //传统设置操作
    让a =  新   组 （“ hello world！”）;
    //'h'e'l'o'''w'r'd''！'
    让b =  新   组 （“ medium is cool！”）;
    //'m'e'd'i'u''s'c'o'l''！'
    //交集
     const 相交=（a，b）=> {
        让交集=  新   组 （）;
        为（让b的元素）{
            如果（a.has（elem））{
                交集.add（elem）;
            }
        }
        回交路口
    }
     安慰 .log（intersection（a，b））;
    //'e'd''``o''l！'
};

// 5- Web API（在浏览器中运行）
const  webapi  = () => {
    // Performance API
     const   开始  =  性能 .now（）;
     const   纤维  = n => {
        如果（n<= 1)  返回  n;
        返回fib（n-1）+  纤维 （n-2）;
    }
      纤维 （15）; 
     const   结束  =  性能 .now（）;
     安慰 .log（结束-开始）;
    // 0.1699999994598329（在我的机器上）

    //导航器API
     航海家 .geolocation.getCurrentPosition（pos => {
         const  {坐标：{纬度，经度}} =  位置 ;
         安慰 .log（纬度，经度）;
        // 48.9080891 2.2699974
     }）; 
}

//取消注释即可运行
//  加 ()
//  调试 ()
//  逗号 ()
//  setDemo ();
//  webapi ()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

// 1-+运算符

const 加 = () => {

//以简写语法获取时间戳

安慰 . 日志 (+ 新日期 ());

//布尔值到整数的转换

安慰 . 日志 (+ 真正 );

安慰 . 日志 (+ 假 );

//科学计数法转换

安慰 . 日志 (+"1e8");

安慰 . 日志 (+ “ 1.6e-2” );

//我最喜欢的随机生成

const 随机 = {

的价值 : () => 数学 . 地板 ( 数学 . 随机 () * 100),

};

安慰 . 日志 (+ 随机 );

};

// 2-调试器语句

//在浏览器中运行或使用--inspect作为节点

const 调试 = () => {

const bubbleSort = ( rr ) => {

const 长度 = rr . 长度 ;

对于 ( 让 i = 0; i < 长度 ; i ++ ) {

对于 ( 让 j = 0; j < 长度 - i - 1; j ++ ) {

如果 ( rr [j] > rr [j + 1]) {

调试器 ;

[ rr [j], rr [j + 1]] = [ rr [j + 1], rr [j]];

}

返回 rr ;

};

安慰 . 日志 ( bubbleSort ([8, 2, 19, 8, 4, 5, 2]));

// 2，2，4，5，8，8，19

};

// 3-逗号运算符

const 逗号 = () => {

让钱 = 10;

const 研究了 = 假 ;

const 放松 = () => 安慰 . 日志 ( “放松” );

const 研究 = () => 安慰 . 日志 ( “研究” );

研究了 ? ( 钱 ++ , 放松 ()) : (( 钱 / = 2), 研究 ());

安慰 . 日志 ( 钱 ); //研究5

//循环中有多个变量

对于 ( 让 i = 1, j = 2; i + j < 10; i ++ , j ++ ) {

安慰 . 日志 (i, j);

}

// 1 2; 2 3; 3 4; 4 5;

//用于调试

const 硬币 = [

{ 值 : 4, 货币 : “欧元” },

{ 值 : 1, 货币 : “美元” },

{ 值 : 5, 货币 : “ BTC” },

];

const countOddCoins = ( 硬币 ) => {

让奇币 = 0;

硬币 . 每次 (({ 值 , 货币 }) => {

如果 ( 值 % 2 ！= 0) {

奇币 ++ , 安慰 . 日志 (`${ 奇币 } 与 ${ 货币 }`);

// 1美元

// 2与BTC

}

});

返回奇币 ;

};

安慰 . 日志 (countOddCoins( 硬币 )); // 2

};

// 4- 组（）对象

const setDemo = () => {

//从数组中删除重复项

const rr = [1, 1, 7, 5, 6, 6, 6, 8, 7];

//旧方法

让 noDup = rr . 过滤 ((a, b) => rr . 指数 (a) === b);

// 新方法

noDup = [... 新组 ( rr )];

安慰 . 日志 ( noDup );

// 1 7 5 6 8

//传统设置操作

让 a = 新组 (“你好世界！”);

//'h'e'l'o'''w'r'd''！'

让 b = 新组 (“中等很酷！”);

//'m'e'd'i'u''s'c'o'l''！'

//交集

const 路口 = (a, b) => {

让路口 = 新组 ();

对于 ( 让元素的 b) {

如果 (a. 拥有 ( 元素 )) {

路口 . 加 ( 元素 );

}

返回路口 ;

}

安慰 . 日志 ( 路口 (a, b));

//'e'd''``o''l！'

};

// 5- Web API（在浏览器中运行）

const webapi = () => {

// Performance API

const 开始 = 性能 . 现在 ();

const 纤维 = n => {

如果 (n <= 1) 返回 n;

返回纤维 (n-1) + 纤维 (n-2);

}

纤维 (15);

const 结束 = 性能 . 现在 ();

安慰 . 日志 ( 结束 - 开始 );

// 0.1699999994598329（在我的机器上）

//导航器API

航海家 . 地理位置 .getCurrentPosition( 位置 => {

const { 座标 : { 纬度 , 经度 } } = 位置 ;

安慰 . 日志 ( 纬度 , 经度 );

// 48.9080891 2.2699974

});

}

//取消注释即可运行

// 加（）

// 调试（）

//逗号（）

// setDemo （）;

// webapi （）

的JavaScript 入侵愉快！ ??‍?

概要

文章名

每个开发人员都应该知道的5个最佳Javascript隐藏技巧

描述

现在比以往任何时候都更具有类似 Node 甚至是独立的基本上到处都是因此，我将向您展示最好的五个隐藏JavaScript技巧。

作者

达斯

发布者名称

达斯

出版商徽标