Question

import java.util.ArrayList; import java.util.List; import java.util.Random; public class Test { List<Integer> randomList = new ArrayList<Integer>(); Random rnd = new Random(); // do not create new Random object in each function call. final static int LIST_SIZE = 25; public void addRandom(List someList) { if (randomList.size() < LIST_SIZE) { int random = rnd.nextInt(101); // LIST_SIZE must be lesser than 101 otherwise you will got infinite recursion. if (!randomList.contains(random)) { randomList.add(random); someList.add(random); } addRandom(someList); } } public static void main(String args[]) { Test test = new Test(); List<Integer> array4 = new ArrayList<Integer>(); test.addRandom(array4); for (Integer value : array4) { System.out.println(value); } } }返回原始数据类型，但我不明白为什么在javascript中使用它？

Answer 1

我不明白为什么在javascript中使用它？

typeof用于

返回[s]原始数据

例如，如果我想知道某些内容是否未定义，我可以

if (typeof object === 'undefined')

要检查，因为如果它是未定义的，则没有数据类型（因为它是未定义的）。这通常是为了使用typeof而不是用于记录目的，查看通过ajax接收的内容，或者用于接受可以具有不同类型的参数并使用typeof检查该类型的函数的原因，等

Answer 2

typeof是一个一元运算符，放在一个可以是任何类型的操作数之前。它的值是一个字符串，它指定操作数的类型。

   - x                             typeof x

   undefined                        "undefined"
   null                             "object"
   true or false                    "boolean"
   any number or NaN                "number"
   any string                       "string"
   any function                     "function"
   any non function native object   "object"

typeof对原始值的效果非常好，除了null.typeof无法区分null和＆amp;对象，因为null是假的＆amp;对象是真实的。这里有few case studies可能有用。 typeof计算对象除了function之外的所有对象和数组值。如何typeof处理函数可能超出了这个问题的范围。

希望这会对你有所帮助。

Answer 3

您可以使用JavaScript typeof运算符来查找JavaScript变量的类型。它也可用于验证变量或输入。解释更好=＆gt; http://www.w3schools.com/js/js_datatypes.asp 示例 typeof“John”//返回字符串typeof 3.14 //返回数字typeof false //返回boolean typeof [1,2,3,4] //返回对象typeof {name：'John'，年龄：34} //返回对象

Answer 4

在javascript中输入为什么使用它？

有时您可能需要检查变量中存储的数据类型，例如，typeof是一个运算符而不是一个函数，它与停止执行函数并从该函数返回值的return语句完全不同

typeof 运算符返回一个字符串，指示未评估的操作数的类型。

console.log(typeof 'name');
// expected output: "string"
console.log(typeof 74);
// expected output: "number"
console.log(typeof true);
// expected output: "boolean"
console.log(typeof declaredButUndefinedVariable);
// expected output: "undefined";

typeof MDN web docs

typeof运算符后面跟着它的操作数：

typeof UnaryExpression =＆gt;请记住，括号是可选的，但请记住：括号对于确定表达式的数据类型非常有用。

var data = 100;
typeof data + ' Bye'; // return 'number Bye'
typeof (data + 'Bye'); // return 'string'

其他例子：

// Numbers
typeof 37 === 'number';
typeof 3.14 === 'number';
typeof(42) === 'number';
typeof Math.LN2 === 'number';
typeof Infinity === 'number';
typeof NaN === 'number'; // Despite being "Not-A-Number"
typeof Number('1') === 'number'; // Number tries to parse things into numbers


// Strings
typeof '' === 'string';
typeof 'bla' === 'string';
typeof `template literal` === 'string';
typeof '1' === 'string'; // note that a number within a string is still typeof string
typeof (typeof 1) === 'string'; // typeof always returns a string
typeof String(1) === 'string'; // String converts anything into a string, safer than toString


// Booleans
typeof true === 'boolean';
typeof false === 'boolean';
typeof Boolean(1) === 'boolean'; // Boolean will convert values based on if they're truthy or falsy, equivalent to !!


// Symbols
typeof Symbol() === 'symbol'
typeof Symbol('foo') === 'symbol'
typeof Symbol.iterator === 'symbol'


// Undefined
typeof undefined === 'undefined';
typeof declaredButUndefinedVariable === 'undefined';
typeof undeclaredVariable === 'undefined'; 


// Objects
typeof {a: 1} === 'object';

// use Array.isArray or Object.prototype.toString.call
// to differentiate regular objects from arrays
typeof [1, 2, 4] === 'object';

typeof new Date() === 'object';
typeof /regex/ === 'object'; // See Regular expressions section for historical results

Answer 5

=SUM(IF(B7:B14=A3,SUMIF(A18:A19,A7:A14,B18:B19)*(C7:C14)))运算符返回一个表示操作数类型的字符串。我们可以通过以下方式使用它来检查值的类型：

typeof

当变量可以具有多个值时，这尤其有用。例如，let nr = 5; if (typeof nr === 'number') { console.log('nr is number'); } let str = 'hi'; if (typeof str === 'string') { console.log('str is string'); }，null或undefined。在这种情况下，我们可以将number运算符与typeof语句结合使用，以便为给定场景执行正确的代码。

Answer 6

以下是常见的骇客入侵类型，有些问题：

const type = obj => Object.prototype.toString.call(obj);

type("abc");// [object String]
type(123);// [object Number]// What's with all the objects?
type([]);// [object Array]
type({});// [object Object]
type(Object.create(null));// [object Object]
type(-1/0);// [object Number] Not exactly a true number
type(NaN);// [object Number] WTF?

如您所见，它存在一些问题。它总是返回用括号括起来的两种类型，第一种总是“对象”。如果总是返回第一种类型的信息，这将使它无用。其次，它的区别还有些局限。它无法告诉我们是将对象创建为文字（纯文本）还是使用Object.create（）创建，该对象在调用时需要关键字“ new”。它也毫不客气地称Infinity和NaN为数字。

我希望分享一种解决所有这些问题的更好的typeof函数。它适用于所有原语，包括符号，异常（错误，未定义，空值和NaN），本机对象和函数的最常见情况（数组，映射，对象，函数，数学，日期，承诺等）以及甚至可以在用户制作的对象（标识为Plain）和DOM元素（标识为HTML）之间进行检测。它应该适用于所有现代和较旧的浏览器。它分为几个功能以使代码更易于使用：

const isDOM = obj => (obj.nodeType && !isPlain(obj)) ? true : false;
const isPlain = obj => obj ? obj.constructor === {}.constructor : false;
const sanString = str => str.replace(/[^a-zA-Z ]/g, "");
const isNaN = obj => (Object.is(obj, NaN) === true) ? true : false;

function objType(obj){
if(obj === undefined) return undefined;
if(obj === Infinity) return Infinity;
if(obj === -Infinity) return -Infinity;
if(isDOM(obj)) return 'HTML';
let str = Object.prototype.toString.call(obj);
if(str === '[object Object]' && isPlain(obj)) return 'Plain';
str = sanString(str).split(' ');
if(str[1] === 'Number' && isNaN(obj)) return NaN;
return str[1];}
}

像这样使用：

objType(null);// Null
objType(undefined);// undefined
objType("abc");// String
objType(123);// Number
objType([]);// Array
objType({});// Plain not [object Object]
objType(Object.create(null));// Object is what we want
objType(document.body);// HTML
objType(-1/0);// -Infinity
objType(NaN);// NaN

如果您发现任何错误或错误或有更好的解决方案（不是来自自由软件公司或freameworks），请告诉我。我会很乐意及时修复它。

在javascript中typeof的用法是什么？

6 个答案: