整合营销服务商

电脑端+手机端+微信端=数据同步管理

免费咨询热线：

JS基本数据类型BigInt

JavaScript 中，有一个特殊的数据类型BigInt,它可以存储非常大的整数，甚至可以存储超过 2 的 32 次方的所有整数。

BigInt是一种无符号整数类型，它可以表示任何正整数，包括无限大和无限小。JavaScript 中的BigInt使用二进制表示法，因此它的值是无限的，并且永远不会溢出或产生舍入误差。

要创建BigInt对象，可以使用Number.bigInt方法。例如，以下代码将创建一个非常大的整数:

let bigInt = Number.bigInt(2**32 + 1);

在这个例子中，2**32 + 1是一个非常大的整数，它可以使用 32 位二进制表示。Number.bigInt方法将返回一个BigInt对象，可以表示这个非常大的整数。

如何创建 BigInt ？

可以用在一个整数字面量后面加 n 的方式定义一个 BigInt ，如：120n，或者调用函数BigInt()。

const theBiggestInt = 9007199254740991n;
const alsoHuge = BigInt(9007199254740991);
console.log(theBiggestInt, alsoHuge);
// 9007199254740991n 9007199254740991n

安全整数的范围

超过这个范围，number类型的数字将会失去精度

Number.MAX_SAFE_INTEGER
// ↪ 99007199254740991    最大安全整数

Number.MIN_SAFE_INTEGER
// ↪ -99007199254740991   最小安全整数

如何使用BigInt

  1. 可以用在一个整数字面量后面加 n 的方式定义一个 BigInt ，如：10n，
  2. 或者调用构造函数 BigInt()（不能使用 new 运算符）并传递一个整数值或字符串值。
const theBiggestInt = 9007199254740991n;

const alsoHuge = BigInt(9007199254740991);
// ↪ 9007199254740991n

const hugeString = BigInt("9007199254740991");
// ↪ 9007199254740991n

const hugeHex = BigInt("0x1fffffffffffff");
// ↪ 9007199254740991n
const hugeBin = BigInt("0b11111111111111111111111111111111111111111111111111111");
// ↪ 9007199254740991n

BigInt类型判断

typeof 123
// ↪ 'number'
typeof 123n
// ↪ 'bigint'
typeof BigInt(123)
// ↪ ''bigint'

BigInt运算

但是BigInt不支持单独使用运算符+，因为会默认为转换成Number，这是不允许的。

const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER);
// ↪ 9007199254740991n

const maxPlusOne = previousMaxSafe + 1n;
// ↪ 9007199254740992n

const theFuture = previousMaxSafe + 2n;
// ↪ 9007199254740993n, this works now!

const multi = previousMaxSafe * 2n;
// ↪ 18014398509481982n

const subtr = multi – 10n;
// ↪ 18014398509481972n

const mod = multi % 10n;
// ↪ 2n

const bigN = 2n ** 54n;
// ↪ 18014398509481984n

bigN * -1n
// ↪ –18014398509481984n

const expected = 4n / 2n;
// ↪ 2n

const rounded = 5n / 2n;
// ↪ 2n, not 2.5n

BigInt比较大小

// 不严格相等，严格不相等
0n === 0
// ↪ false

0n == 0
// ↪ true


// Number 和 BigInt 可以直接比较。
1n < 2
// ↪ true

2n > 1
// ↪ true

2 > 2
// ↪ false

2n > 2
// ↪ false

2n >= 2
// ↪ true

// BigInt可以和Number混入数组中进行排序
const mixed = [4n, 6, -12n, 10, 4, 0, 0n];
// ↪  [4n, 6, -12n, 10, 4, 0, 0n]

mixed.sort();
// ↪ [-12n, 0, 0n, 10, 4n, 4, 6]

BigInt无法使用JSON.stringify()方法

对任何 BigInt 值使用 JSON.stringify() 都会引发 TypeError，因为默认情况下 BigInt 值不会在 JSON 中序列化。但是，如果需要，可以实现 toJSON 方法：

BigInt.prototype.toJSON = function() { return this.toString(); }
// 现在可以
JSON.stringify(BigInt(1));
// ↪ '"1"'

需要注意的是，BigInt对象是不可变的，也就是说，一旦创建，就无法更改其值。如果需要更改BigInt对象的值，必须创建一个新的BigInt对象。

BigInt对象在 JavaScript 中主要用于处理非常大的整数，例如在密码学和安全方面。

总结

  1. BigInt不能和Number类型数据混合运算，两者必须转换成同一种数据类型。BigInt和Number联众类型互相转换时，要注意可能会丢失精度
  2. BigInt和Numner可以直接作大小比较。
  3. BigInt可以和大部分运算符一起使用，除了单独使用+，因为会默认强制转化类型。
  4. BigInt作为条件判断转为Boolean时，和Number类型一致。
  5. 默认情况下BigInt无法在JSON中序列化
  6. bignumber.js 也是一种处理最大安全整数的方法
  7. BigInt不能调用Math中的方法

扣 374. 猜数字大小

题目描述

猜数字游戏的规则如下：

  • 每轮游戏，我都会从 1 到 n 随机选择一个数字。请你猜选出的是哪个数字。
  • 如果你猜错了，我会告诉你，你猜测的数字比我选出的数字是大了还是小了。

你可以通过调用一个预先定义好的接口 int guess(int num) 来获取猜测结果，返回值一共有 3 种可能的情况（-1，1 或 0）：

  • -1：我选出的数字比你猜的数字小 pick < num
  • 1：我选出的数字比你猜的数字大 pick > num
  • 0：我选出的数字和你猜的数字一样。恭喜！你猜对了！pick == num

返回我选出的数字。

示例 1：

输入：n = 10, pick = 6
输出：6

示例 2：

输入：n = 1, pick = 1
输出：1

示例 3：

输入：n = 2, pick = 1
输出：1

示例 4：

输入：n = 2, pick = 2
输出：2

提示：

  • 1 <= n <= 2^31 - 1
  • 1 <= pick <= n


解决方案

方法一：二分查找

记选出的数字为 pick ，猜测的数字为 x 。根据题目描述，若 guess(x)≤0 则说明 x≥pick，否则 x<pick。

根据这一性质我们可以使用二分查找来求出答案 pick。

二分时，记当前区间为[left,right]，初始时 left=1，right=n。记区间中间元素为 mid，若有 guess(mid)≤0 则说明 pick∈[left,mid]，否则 pick∈[mid+1,right]。当区间左右端点相同时，则说明我们找到了答案，退出循环。

C++

class Solution {
public:
    int guessNumber(int n) {
        int left = 1, right = n;
        while (left < right) { // 循环直至区间左右端点相同
            int mid = left + (right - left) / 2; // 防止计算时溢出
            if (guess(mid) <= 0) {
                right = mid; // 答案在区间 [left, mid] 中
            } else {
                left = mid + 1; // 答案在区间 [mid+1, right] 中
            }
        }
        // 此时有 left == right，区间缩为一个点，即为答案
        return left;
    }
};

Java

public class Solution extends GuessGame {
    public int guessNumber(int n) {
        int left = 1, right = n;
        while (left < right) { // 循环直至区间左右端点相同
            int mid = left + (right - left) / 2; // 防止计算时溢出
            if (guess(mid) <= 0) {
                right = mid; // 答案在区间 [left, mid] 中
            } else {
                left = mid + 1; // 答案在区间 [mid+1, right] 中
            }
        }
        // 此时有 left == right，区间缩为一个点，即为答案
        return left;
    }
}

C#

public class Solution : GuessGame {
    public int GuessNumber(int n) {
        int left = 1, right = n;
        while (left < right) { // 循环直至区间左右端点相同
            int mid = left + (right - left) / 2; // 防止计算时溢出
            if (guess(mid) <= 0) {
                right = mid; // 答案在区间 [left, mid] 中
            } else {
                left = mid + 1; // 答案在区间 [mid+1, right] 中
            }
        }
        // 此时有 left == right，区间缩为一个点，即为答案
        return left;
    }
}

Golang

func guessNumber(n int) int {
    return sort.Search(n, func(x int) bool { return guess(x) <= 0 })
}

JavaScript

var guessNumber = function(n) {
    let left = 1, right = n;
    while (left < right) { // 循环直至区间左右端点相同
        const mid = Math.floor(left + (right - left) / 2); 
        if (guess(mid) <= 0) {
            right = mid; // 答案在区间 [left, mid] 中
        } else {
            left = mid + 1; // 答案在区间 [mid+1, right] 中
        }
    }
    // 此时有 left == right，区间缩为一个点，即为答案
    return left;
};

C

int guessNumber(int n) {
    int left = 1, right = n;
    while (left < right) {  // 循环直至区间左右端点相同
        int mid = left + (right - left) / 2;  // 防止计算时溢出
        if (guess(mid) <= 0) {
            right = mid;  // 答案在区间 [left, mid] 中
        } else {
            left = mid + 1;  // 答案在区间 [mid+1, right] 中
        }
    }
    // 此时有 left == right，区间缩为一个点，即为答案
    return left;
}

Python3

class Solution:
    def guessNumber(self, n: int) -> int:
        left, right = 1, n
        while left < right:
            mid = (left + right) // 2
            if guess(mid) <= 0:
                right = mid   # 答案在区间 [left, mid] 中
            else:
                left = mid + 1   # 答案在区间 [mid+1, right] 中
        
        # 此时有 left == right，区间缩为一个点，即为答案
        return left


复杂度分析

  • 时间复杂度：O(logn)。时间复杂度即为二分的次数，每次二分我们将区间的长度减小一半，直至区间长度为 1 时二分终止，而区间初始长度为 n，因此二分次数为 O(logn)。
  • 空间复杂度：O(1) 。


BY /

本文作者：力扣

声明：本文归“力扣”版权所有，如需转载请联系。

avaScript

BOM:浏览器对象模型

一套操作浏览器功能的API

通过BOM可以操作浏览器窗口，比如弹出框、控制浏览器跳转、获取分辨率等

DOM:文档对象模型

一套操作页面元素的API

DOM可以把HTML看到是文档树，通过DOM提供的API可以对树上的节点进行操作

接受用户的输入

prompt：类似python当中的input；

多行注释

/*

这是多行注释

这是多行注释

/*

变量赋值

var num1; // 声明变量

var num1 = 1; // 声明变量并赋值

var num1, num2, num3; // 同时声明多个变量

数字

判断一个变量是不是一个数字；

var cce='1';

console.log(isNaN(cce));

// false isNaN的意思就是不是一个数字，那么现在我们给的一个数字就会返回一个false

转移符

字面量含义\n换行\t制表\b空格\r回车\斜杠

获取字符串的长度

string.length：获取string字符串的长度；

var str = '蔡长恩';

console.log(str.length);

// 3

数据类型

获取变量的类型

typeof(data)：获取变量的类型；

var str = '蔡长恩';

console.log(typeof(str));

// string

数字类型转换

toString：转换为string类型；

String()：直接转为字符串类型；

parseInt：直接转为数字类型；

parseFloat：直接转为浮点类型；

var num=1;

console.log(typeof String(num)) // 数字转字符串

// string

console.log(typeof num.toString()) // 数字转字符串

// string

var num='1';

console.log(typeof parseInt(num))

// number

bool类型转换

Boolean()：转为bool类型；

注意：结果为false有几种情况 null undefined '' 0 NaN


在线咨询
上一篇：JavaScript Loop教程–如何在JavaScript中遍历数组
下一篇：PyScript：让Python在HTML中运行

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

推荐阅读
友情链接 垣曲县 峄城区 望都县 义马市 固镇县 凌海市 网站制作
Copyright © 2002-2019 雨点网络设计有限公司 版权所有   冀ICP备11025394号
联系电话：   E-mail：279303980@qq.com  
主营业务：技术文章网站建设、网站定制、技术文章营销型网站建设、技术文章网站优化、技术文章微商城制作、三级分销系统开发
电话沟通
在线客服