JavaScript从零开始学习第8天

一.数组内置对象

今天就是一些方法的展示了，全部都是记的一些方法。理解性记忆或跟着英文的意思一起记就行了。
这个是连着昨天一起写的了
这个对象也可以叫做方法。其实每次我们创建数组是其实都通过官方的构造函数。

        var arr1 = [10, 20, 30];
        var arr2 = new Array();
        arr2[0] = 10;
        arr2[1] = 20;
        arr2[2] = 30;
        console.log(arr1,arr2)//输出arr1,arr2数组

第一种就是一种语法糖，简写了一些步骤，但我们要知道本质还后面那种。所以我们就可以使用Array函数中原型链中方法。

1.fill() 方法

在JavaScript中，fill() 方法是一个数组方法，用于将数组的所有元素都替换为静态值。fill() 方法会修改原始数组，并返回修改后的数组。
fill() 方法有两个参数：
1.value：要用来填充数组的值。
2.start（可选）：填充开始的索引，默认值为 0。
3.end（可选）：填充结束的索引，默认值为数组的长度。

var array = [1, 2, 3, 4, 5];
// 将数组中的所有元素替换为 0
array.fill(0);
console.log(array); // 输出 [0, 0, 0, 0, 0]
// 从索引 1 开始，将数组中的元素替换为 10，直到索引 3（不包括索引 3）
array.fill(10, 1, 3);
console.log(array); // 输出 [0, 10, 10, 0, 0]

2.findIndex()方法

在JavaScript中，findIndex() 方法是一个数组方法，用于查找数组中满足指定条件的第一个元素的索引值。如果找到符合条件的元素，则返回该元素的索引值；如果没有找到符合条件的元素，则返回 -1。
findIndex() 方法有一个参数：
1.callback：一个回调函数，用于指定查找条件。该回调函数接收三个参数：element（当前元素的值）、index（当前元素的索引）、array（原始数组）。

//例子1
var array1 = [1, 2, 3, 4, 5];
// 查找数组中第一个大于 3 的元素的索引
var index = array1.findIndex((element) => element > 3);
console.log(index); // 输出 3
//例子2
var array2 = [1, 2, 3, 4, 5];
// 查找数组中第一个大于 10 的元素的索引
var index2 = array2.findIndex((element) => element > 10);
console.log(index2); // 输出 -1
//例子3
var numbers = [1, 3, 5, 7, 2, 4, 6];
function isEven(element) {
  return element % 2 === 0;
}
const index = numbers.findIndex(isEven);
console.log(index); // 输出 4

这样看来这个findIndex函数就是先将数组的元素值取出来然后放入所调用的函数中，满足返回值的元素值的在通过findIndex的返回值出去，最后输出索引值。

3.flat()方法

flat 方法是数组的原生方法，用于将多维数组拍平为一维数组。它会将数组中的每个元素递归展开，直到所有的元素都位于一个新的一维数组中。
flat 方法有一个可选的参数 depth，用于指定展开的深度。如果不传递 depth 参数，默认值为 1，即只拍平一层数组。如果传递一个大于 0 的整数作为 depth 参数，将会展开指定的深度。如果传递一个负数，将会拍平所有嵌套的数组。

var arr = [1, 2, [3, 4, [5, 6]]];
var arr1 = arr.flat();
console.log(arr1); // 输出 [1, 2, 3, 4, [5, 6]]
var arr2 = arr.flat(2);
console.log(arr2); // 输出 [1, 2, 3, 4, 5, 6]
var arr3 = arr.flat(Infinity);
console.log(fullyFlattenedArr); // 输出 [1, 2, 3, 4, 5, 6]

4.flatMap()方法

在JavaScript中，有一个内置的flatMap方法可以用来展开嵌套数组并进行转换操作。flatMap方法首先对原数组中的每一个元素执行一个映射函数，然后将映射结果展开为一个新的数组。

var arr = [1, 2, [3, 4], 5, [6, [7, 8]]];

var flattenedArr = arr.flatMap(function(item) {
  if (Array.isArray(item)) {
    return item;
  } else {
    return [item];
  }
});

console.log(flattenedArr);
// Output: [1, 2, 3, 4, 5, 6, [7, 8]]

5.includes()方法

includes方法是JavaScript中一个数组的方法，用于检查数组是否包含特定的元素。它返回一个布尔值，表示数组中是否包含要搜索的元素。

var arr = [1, 2, 3, 4, 5];

console.log(arr.includes(3));
// Output: true

console.log(arr.includes(6));
// Output: false

6.lastIndexOf()方法

lastIndexOf方法是JavaScript中字符串和数组的方法之一，用于返回指定元素在字符串或数组中最后一次出现的位置。

var str = 'hello world';

console.log(str.lastIndexOf('o'));
// Output: 7

var arr = [1, 2, 3, 4, 3, 2, 1];

console.log(arr.lastIndexOf(3));
// Output: 4

需要注意的是，lastIndexOf方法从后往前搜索元素，并返回首次出现的位置。如果元素不存在，则返回-1。

7.reverse()方法

reverse()方法是JavaScript中数组的一个方法，用于将数组中的元素顺序颠倒。
会修改原数组，返回值是新数组。

var arr = [1, 2, 3, 4, 5];
console.log(arr.reverse());
// Output: [5, 4, 3, 2, 1]

然后，我们使用reverse()方法对数组进行颠倒顺序操作。该方法会直接修改原数组，而不是创建一个新的数组。在这个例子中，arr数组的顺序将被改变为[5, 4, 3, 2, 1]。
需要注意的是，reverse()方法会改变原数组，所以在使用之前最好先创建原数组的备份。

一道练习：

     function fn(str) {
       var re = str.split("").reverse().join("")
      console.log(re)
      return str == re
    }
     var a = "从上海交大校内学生"
     var re = fn("上海自来水来自海上")//true  false
     console.log(re)

8.toSpliced()方法

相对比较新的方法，相较于spliced()方法，该方法的好处在于不会修改原数组。

    var arr = [10, 230, 104];
    var re=arr.toSpliced(1,1,666,777);
    console.log(arr,re)//输出[10,230,104]   [10,666,777,104]

9.toSorted()方法

该方法也于sort方法一样，唯一区别在于不会修改原数组。

var arr=[9,10,4,3,2,5]
var re=arr.toSorted(function(n1,n2){return n1-n2})
     console.log(re,arr)//[2,3,4,5,9,10]  [9,10,4,3,2,5]

9.with()方法

with方法也是比较新的方法，调用此方法时并不会改变原数组。作用是选择数组一个元素改成另一个值。
with() 方法有两个参数：
第一个参数选择数组的索引值。
第二个参数则是想要改成的值。

      var arr = [9, 10, 4, 3, 2, 5]
        var re = arr.with(0, 2)
        console.log(re, arr)//输出[2,10,4,3,2,5]   [9,10,4,3,2,5]

10.toReversed()方法

toReversed()方法的作用跟reversed方法作用一样，唯一区别在于并不会改变原数组。

 var arr = [9, 10, 4, 3, 2, 5]
        var arr2 = arr.toReversed()
        console.log(arr,arr2)//[5,2,3,4,10,9]   [9,10,4,3,2,5]

11.toLocaleString()方法

toLocaleString()方法是将数组转化为字符串，并不会改变原数组。

        var arr = [9, 10, 4, 3, 2, 5]
        var re = arr.toLocaleString()
        console.log(re,arr) 9，10，4，3，2，5   [9,10,4,3,2,5]

二.遍历器

在JavaScript中，可以使用遍历器（iterator）来遍历可迭代对象（iterable objects），如数组、字符串、Map、Set等。
for循环就是一种遍历器。

var arr=[10,2,3,45,5,76]
     for(var i=0;i<arr.length;i++){
       console.log(arr[i])
     }

1.使用in来遍历

在JavaScript中，in运算符可以用来遍历对象的属性。当应用于对象时，in运算符会遍历对象的所有可枚举属性（包括原型链上的属性）。

 var arr = [10, 2, 3, 45, 5, 76]
        for (index in arr) {
            console.log(arr[index])
        }
        var obj = {a: 1, b: 2, c: 3};

for (var prop in obj) {
  if (obj.hasOwnProperty(prop)) {
    console.log(prop + ": " + obj[prop]);
  }
}

需要注意的是，for…in循环会遍历对象的所有可枚举属性，包括原型链上的属性。如果只想遍历对象自身的属性，可以使用Object.hasOwnProperty()方法进行过滤

需要注意的是，in运算符适用于数组和其他对象类型。当应用于数组时，它会检查指定的索引是否在数组的范围内。当应用于其他对象时，它会检查指定的属性是否存在于对象中。

var arr = [1, 2, 3, 4];

console.log(0 in arr); // 输出：true，数组中存在索引为0的元素
console.log(2 in arr); // 输出：true，数组中存在索引为2的元素
console.log(5 in arr); // 输出：false，数组中不存在索引为5的元素

2.使用of来遍历

在JavaScript中，of关键字可以用于遍历可迭代对象（如数组、字符串等），而不是用于遍历对象的属性。

var arr = [1, 2, 3];

for (var element of arr) {
  console.log(element);
}//输出1  2  3
var str = "Hello";

for (var char of str) {
  console.log(char);
}//输出 H  e  l  l  o

需要注意的是，for…of循环只能遍历可迭代对象的值，而不能获取索引或键。如果需要获取索引或键，可使用for…in循环。

3.使用map方法来遍历

map()方法可以用于遍历数组，并对每个元素执行指定的操作，然后返回一个新的数组。

var arr = [1, 2, 3];

var newArr = arr.map(function(element) {
  return element * 2;
});

console.log(newArr);//[2,4,6]

map函数的的自己实现

function myMap(arr, callback) {
  var newArr = [];
  for(var i = 0; i < arr.length; i++) {
    newArr.push(callback(arr[i], i, arr));
  } 
  return newArr;
}
var arr = [1, 2, 3];
var newArr = myMap(arr, function(element) {
  return element * 2;
});
console.log(newArr);//输出2 4 6

4.使用filter()方法来遍历

使用 filter() 方法来遍历数组，并返回满足指定条件的元素组成的新数组。

var arr = [1, 2, 3, 4, 5];

var newArr = arr.filter(function(element) {
  return element % 2 === 0;
});

console.log(newArr);//输出[2,4]

写一个与filter()方法类似的函数

function myFilter(arr, callback) {
  var newArr = [];

  for (var i = 0; i < arr.length; i++) {
    if (callback(arr[i], i, arr)) {
      newArr.push(arr[i]);
    }
  }

  return newArr;
}
var arr = [1, 2, 3, 4, 5];

var newArr = myFilter(arr, function(element) {
  return element % 2 === 0;
});

console.log(newArr);//输出 [2,4]

5.使用every()方法来遍历

使用 every() 方法来遍历数组并检查数组中的每个元素是否满足指定的条件。every() 方法会在数组中的每个元素上调用一个回调函数，直到回调函数返回 false 或遍历完所有元素为止。

var arr = [1, 2, 3, 4, 5];

var allEven = arr.every(function(element) {
  return element % 2 === 0;
});

console.log(allEven);//输出false

全都没有满足才会输出true

6.使用some()方法来遍历

使用 some() 方法来遍历数组并检查数组中的某个元素是否满足指定的条件。some() 方法会在数组中的每个元素上调用一个回调函数，直到回调函数返回 true 或遍历完所有元素为止。

var arr = [1, 2, 3, 4, 5];

var hasEven = arr.some(function(element) {
  return element % 2 === 0;
});

console.log(hasEven);//输出true

有满足则会输出true

7.使用reduce()方法来遍历

使用 reduce() 方法来遍历数组并对数组中的元素进行累积计算。reduce() 方法接受一个回调函数作为参数，并且可以传递一个初始值作为累积的起始值。

var arr = [1, 2, 3, 4, 5];

var sum = arr.reduce(function(accumulator, currentValue) {
  return accumulator + currentValue;
}, 0);

console.log(sum);//输出15

在初始值为0的情况下，回调函数将首先将累积值设置为0，然后将第一个元素1添加到累积值上，得到1。接下来，将第二个元素2添加到累积值上，得到3。以此类推，直到遍历完所有元素，得到最终的累积值15。

8.使用reduceRight()方法来遍历

在 JavaScript 中，可以使用 reduceRight() 方法来从数组的最后一个元素开始，向前遍历数组并对数组中的元素进行累积计算。reduceRight() 方法接受一个回调函数作为参数，并且可以传递一个初始值作为累积的起始值。

var arr = [1, 2, 3, 4, 5];

var sum = arr.reduceRight(function(accumulator, currentValue) {
  return accumulator + currentValue;
}, 0);

console.log(sum);//输出15

与reduce类型，但遍历方向相反

三.字符串的内置对象

字符串有一些内置对象可以使用。以下是一些常用的字符串内置对象
虽然字符串为基础数据，但也有一些对象可以使用。当字符串调用该方法时会隐式声明了一个字符串对象。基础数据不可改变，也就不用担心原数据被改变了。

1.split()

split() 是字符串对象的内置方法之一，用于将字符串分割成子字符串数组。它接受一个参数作为分隔符，并返回一个由分割后的子字符串组成的数组。
语法：string.split(separator, limit)
参数：separator（可选）：用于分隔字符串的字符或字符串。如果不提供此参数，split() 方法将返回一个只包含整个字符串的数组。
limit（可选）：指定返回的数组的最大长度。如果提供此参数，split() 方法将截断数组，使其长度不超过限制。

var str = "Hello,World,JavaScript";
var arr = str.split(",");
console.log(arr); // 输出: ["Hello", "World", "JavaScript"]

var str2 = "1 2 3 4 5";
var arr2 = str2.split(" ", 3);
console.log(arr2); // 输出: ["1", "2", "3"]

2.slice()

在 JavaScript 中，slice() 是字符串对象的内置方法之一，用于从字符串中提取指定位置的子字符串。它接受两个参数，分别是起始位置和结束位置（可选），并返回一个新的字符串。
语法：string.slice(start, end)
参数：start：指定要提取的子字符串的起始位置。如果为负数，则表示从字符串末尾开始计算的偏移量。如果不提供此参数，则默认从索引 0 处开始提取。
end（可选）：指定要提取的子字符串的结束位置（不包括此位置的字符）。如果为负数，则表示从字符串末尾开始计算的偏移量。如果不提供此参数，则默认提取到字符串的末尾。

var str = "Hello, World!";
var newStr = str.slice(7);
console.log(newStr); // 输出: "World!"

var newStr2 = str.slice(7, 12);
console.log(newStr2); // 输出: "World"

3.toLowerCase()

在 JavaScript 中，toLowerCase() 是字符串对象的内置方法之一，用于将字符串中的所有字符转换为小写。

var str = "HELLO, WORLD!";
var lowerStr = str.toLowerCase();
console.log(lowerStr); // 输出: "hello, world!"

4.toUpperCase()

toUpperCase() 是字符串对象的内置方法之一，用于将字符串中的所有字符转换为大写。

var str = "hello, world!";
var upperStr = str.toUpperCase();
console.log(upperStr); // 输出: "HELLO, WORLD!"

5.charCodeAt()

charCodeAt() 是字符串对象的内置方法之一，用于获取指定索引位置字符的 Unicode 编码值。

var str = "Hello";
console.log(str.charCodeAt(0)); // 输出: 72
console.log(str.charCodeAt(4)); // 输出: 111

6.indexOf()

ndexOf()是字符串对象的内置方法之一，用于查找指定字符串或字符在一个字符串中首次出现的位置索引。
语法：string.indexOf(searchValue, fromIndex)
参数 searchValue 是要搜索的字符串或字符。
参数 fromIndex 是可选的，表示搜索起始位置的索引，默认为 0。如果传递一个负值，则将其视为从字符串末尾开始搜索的偏移量。
返回值是一个表示首次出现的位置索引的整数。如果未找到搜索值，则返回 -1。

var str = "Hello world";
console.log(str.indexOf("o")); // 输出: 4
console.log(str.indexOf("world")); // 输出: 6
console.log(str.indexOf("o", 5)); // 输出: 7
console.log(str.indexOf("x")); // 输出: -1

7.endsWith()

endsWith()用于检查一个字符串是否以指定的字符串或字符结尾。
语法：string.endsWith(searchValue, length)
参数 searchValue 是要搜索的字符串或字符。
参数 length 是可选的，表示在字符串中要考虑的字符数。如果未指定该参数，则将考虑整个字符串长度。如果指定了该参数，则只检查前length个字符是否以searchValue结尾。
返回值是一个布尔值，表示字符串是否以searchValue结尾。如果是，则返回true，否则返回false。

var str = "Hello world";
console.log(str.endsWith("world")); // 输出: true
console.log(str.endsWith("world", 6)); // 输出: false
console.log(str.endsWith("o")); // 输出: false
console.log(str.endsWith("o", 8)); // 输出: true

8.startWith()

startsWith()用于检查一个字符串是否以指定的字符串或字符开始。
语法：string.startsWith(searchValue, position)
参数 searchValue 是要搜索的字符串或字符。
参数 position 是可选的，表示在字符串中要开始搜索的位置。如果未指定该参数，则从字符串的第一个字符开始搜索。如果指定了该参数，则从指定的位置开始搜索。
返回值是一个布尔值，表示字符串是否以searchValue开始。如果是，则返回true，否则返回false。

var str = "Hello world";
console.log(str.startsWith("Hello")); // 输出: true
console.log(str.startsWith("hello")); // 输出: false
console.log(str.startsWith("world", 6)); // 输出: true
console.log(str.startsWith("r", 8)); // 输出: true

9.padStart()

padStart()它用于将当前字符串用指定的字符串填充到指定的目标长度。
语法：string.padStart(targetLength, padString)
参数 targetLength 是填充后的目标长度。如果当前字符串的长度小于目标长度，则会在开始位置填充指定的字符串。
参数 padString 是用于填充的字符串。如果不提供该参数，则默认使用空格填充。
返回值是一个新的字符串，表示填充后的结果。

var str = "Hello";
console.log(str.padStart(10)); // 输出: "     Hello"
console.log(str.padStart(10, "*")); // 输出: "*****Hello"
console.log(str.padStart(2)); // 输出: "Hello"

10.padEnd()

padEnd()它用于将当前字符串用指定的字符串填充到指定的目标长度。不过是反之来的。
语法：string.padEnd(targetLength, padString)
参数 targetLength 是填充后的目标长度。如果当前字符串的长度小于目标长度，则会在开始位置填充指定的字符串。
参数 padString 是用于填充的字符串。如果不提供该参数，则默认使用空格填充。
返回值是一个新的字符串，表示填充后的结果。

var str = "Hello";
console.log(str.padEnd(10)); // 输出: "Hello     "
console.log(str.padEnd(10, "*")); // 输出: "Hello*****"
console.log(str.padEnd(2)); // 输出: "Hello"

11.字符串加特效

类似于thml的标签类似，给文字加点效果，不过不如css直接改变。

   var str = "2"
    var re = str.big()
    var re = str.small()
    var re = str.sub()
    var re = str.sup()
    var re = str.fontcolor("red")
    var re = str.fontsize("30px")
    var re = str.bold()
    var re = str.italics()
    var re = str.link("http://www.baidu.com")
    var re = str.hqyj("19px", "#000")
    // var re = str.blink()
    console.log(re)
    document.body.innerHTML += `H${re}O`

类似于标签吧，先随便记记吧。

12.一道练习题

 //笔试题: 去掉字符串的首尾的空字符 (至少3种)
     var str = "   abc  "
     var re = str.trim()
     console.log("66666" + re + "8888")

1.使用trim()方法：

var str = "   abc  ";
var trimmedStr = str.trim();
console.log("66666" + trimmedStr + "8888"); // 输出: "66666abc8888"

2.使用正则表达式：

var str = "   abc  ";
var trimmedStr = str.replace(/^\s+|\s+$/g, "");
console.log("66666" + trimmedStr + "8888"); // 输出: "66666abc8888"

3.自定义函数：

function trimString(str) {
  var start = 0;
  var end = str.length - 1;

  while (start <= end && str.charAt(start) === " ") {
    start++;
  }

  while (end >= start && str.charAt(end) === " ") {
    end--;
  }

  return str.substring(start, end + 1);
}

var str = "   abc  ";
var trimmedStr = trimString(str);
console.log("66666" + trimmedStr + "8888"); // 输出: "66666abc8888"

四.Math的内置对象

Math是JavaScript的内置对象，提供了许多数学相关的方法和属性。

1.Math.PI

Math.PI是JavaScript中的一个内置常量，表示圆周率 π，其值近似为3.141592653589793。它可以用于各种计算。

2.Math.floor

Math.floor用于向下取整

console.log(Math.floor(3.9)); // 输出：3，向下取整为最接近的整数，即3
console.log(Math.floor(7.2)); // 输出：7，向下取整为最接近的整数，即7
console.log(Math.floor(-2.5)); // 输出：-3，向下取整为最接近的整数，即-3

3.Math.ceil

Math.ceil用于向上取整

console.log(Math.ceil(3.2)); // 输出：4，向上取整为最接近的整数，即4
console.log(Math.ceil(8.7)); // 输出：9，向上取整为最接近的整数，即9
console.log(Math.ceil(-4.5)); // 输出：-4，向上取整为最接近的整数，即-4

4.Math.round

Math.round用于四舍五入取整。

console.log(Math.round(3.2)); // 输出：3，四舍五入为最接近的整数，即3
console.log(Math.round(8.7)); // 输出：9，四舍五入为最接近的整数，即9
console.log(Math.round(-4.5)); // 输出：-4，四舍五入为最接近的整数，即-4

5.Math.max

Math.max作用用于返回一个最大值。

console.log(Math.max(2, 5, 1, 9, 3)); // 输出：9，返回一组数值中的最大值，即9
console.log(Math.max(-1, -5, -3)); // 输出：-1，返回一组数值中的最大值，即-1
console.log(Math.max(10)); // 输出：10，只有一个数值时，返回该数值本身

6.Math.min

Math.min用于返回一个最小值

console.log(Math.min(2, 5, 1, 9, 3)); // 输出：1，返回一组数值中的最小值，即1
console.log(Math.min(-1, -5, -3)); // 输出：-5，返回一组数值中的最小值，即-5
console.log(Math.min(10)); // 输出：10，只有一个数值时，返回该数值本身

7.Math.log10

Math.log10用于计算一个以log10为底的对数。

console.log(Math.log10(10)); // 输出：1，10的以10为底的对数为1
console.log(Math.log10(100)); // 输出：2，100的以10为底的对数为2
console.log(Math.log10(1000)); // 输出：3，1000的以10为底的对数为3
console.log(Math.log10(1)); // 输出：0，1的以10为底的对数为0

8.Math.sqrt

Math.sqrt用于计算一个数的平方根。

console.log(Math.sqrt(4)); // 输出：2，4的平方根为2
console.log(Math.sqrt(9)); // 输出：3，9的平方根为3
console.log(Math.sqrt(16)); // 输出：4，16的平方根为4

9.Math.SQRT1_2

Math.SQRT1_2是JavaScript中Math对象的一个常量，表示1/√2的近似值。

10.三角函数

     var deg = Math.PI / 180
     re = Math.sin(45 * deg)//sin 45 度的值
     re = Math.cos(0 * deg)//cos 0 度的值
     re = Math.tan(45 * deg)//tan45度的值

11.Math.random()

Math.random()的返回值是一个在0到1之间的随机数，它是一个均匀分布的伪随机数。每次调用Math.random()都会生成一个不同的随机数。

console.log(Math.random()); // 输出：介于0到1之间的随机数，例如：0.7284266946754584

// 生成一个介于1到10之间的随机整数
var randomInt = Math.floor(Math.random() * 10) + 1;
console.log(randomInt); // 输出：介于1到10之间的随机整数，例如：7

// 生成一个介于min和max之间的随机整数
function getRandomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

var randomNum = getRandomInt(5, 15);
console.log(randomNum); // 输出：介于5到15之间的随机整数，例如：12

12.Math.pow

用于计算一个数的指数幂

console.log(Math.pow(2, 3)); // 输出：8，表示2的3次方

console.log(Math.pow(10, -2)); // 输出：0.01，表示10的-2次方

console.log(Math.pow(5, 0)); // 输出：1，任何数的0次方都等于1

// 通过Math.pow()计算平方根
var num = 25;
console.log(Math.pow(num, 0.5)); // 输出：5，表示25的平方根

// 通过Math.pow()计算立方根
var num = 27;
console.log(Math.pow(num, 1/3)); // 输出：3，表示27的立方根

13.Math.hypot

Math.hypot(x, y, …)接受一到多个参数，表示要计算平方和的值。它会返回这些值的平方和的平方根。

console.log(Math.hypot(3, 4)); // 输出：5，表示计算(3^2 + 4^2)的平方根，即5

console.log(Math.hypot(1, 2, 3)); // 输出：3.7416573867739413，表示计算(1^2 + 2^2 + 3^2)的平方根，即3.7416573867739413

console.log(Math.hypot(5, 12, 13)); // 输出：18，表示计算(5^2 + 12^2 + 13^2)的平方根，即18

// 通过Math.hypot()计算直角三角形斜边长度
var a = 3;
var b = 4;
var c = Math.hypot(a, b);
console.log(c); // 输出：5，表示计算(3^2 + 4^2)的平方根，即5