ఇస్క్రిప్ట్ బౌలియన్ ఆపరేటర్లు

బౌలియన్ ఆపరేటర్లు చాలా ముఖ్యమైనవి, వాటితో ప్రోగ్రామింగ్ లాంగ్వేజ్ సరళంగా పని చేస్తుంది.

బౌలియన్ ఆపరేటర్లు మూడు ఉన్నాయి: NOT, AND, OR

ToBoolean ఆపరేషన్

వివిధ లాజికల్ ఆపరేటర్లను నేర్చుకునే ముందు, మామల్లో ఈస్క్రిప్ట్-262 v5 ప్రామాణికంలో పేర్కొన్న ToBoolean ఆపరేషన్ ను తెలుసుకోండి.

అబ్స్ట్రాక్ట్ ఆపరేషన్ ToBoolean దాని పారామీటర్లను క్రింది పట్టికలో చేర్చబడే నియమాల ప్రకారం లాజికల్ విలువలకు మారుస్తుంది:

పారామీటర్ రకం 结果
అనిర్దేశిత false
నెల్లు false
బౌలియన్ ఫలితం ప్రవేశం మలుపులో ఉంటుంది (మార్పిడి లేదు)
నంబర్ పారామీటర్ +0, -0 లేదా NaN అయితే ఫలితం false అవుతుంది; లేకపోతే true అవుతుంది。
స్ట్రింగ్ పారామీటర్ ఖాళీ స్ట్రింగ్ అయితే ఫలితం false అవుతుంది; లేకపోతే true అవుతుంది。
ఆబ్జెక్ట్ true

లాజిక్ NOT ఆపరేటర్

在 ECMAScript 中，逻辑 NOT 运算符与 C 和 Java 中的逻辑 NOT 运算符相同，都由感叹号（!）表示。

లాజికల్ OR మరియు లాజికల్ AND ఆపరేటర్స్ తో వ్యత్యాసంగా ఉంటుంది కాదు లాజికల్ NOT ఆపరేటర్లాజికల్ నాట్ ఆపరేటర్ తిరిగిస్తుంది ఎప్పటికీ బౌల్ విలువ.

లాజికల్ నాట్ ఆపరేటర్ ప్రవర్తన ఈ విధంగా ఉంటుంది:

  • ఆపరేండ్ ఆబ్జెక్ట్ ఉంటే సమాచారం ఉంటుంది
  • ఆపరేండ్ 0 ఉంటే సమాచారం ఉంటుంది
  • ఆపరేండ్ 0 కంటే ఎక్కువ ఏ సంఖ్యలను తిరిగిస్తుంది సమాచారం ఉంటుంది
  • ఆపరేండ్ null ఉంటే సమాచారం ఉంటుంది
  • ఆపరేండ్ NaN ఉంటే సమాచారం ఉంటుంది
  • ఆపరేండ్ యున్డిఫైన్డ్ ఉంటే దోషం జరుగుతుంది

సాధారణంగా, ఈ ఆపరేటర్ సైకిల్స్ నియంత్రించటానికి ఉపయోగించబడుతుంది:

var bFound = false;
var i = 0;
while (!bFound) {
  if (aValue[i] == vSearchValues) {
    bFound = true;
  } else {
    i++;
  }
}

ఈ ఉదాహరణలో, బౌల్ వేరీయాబుల్ (bFound) సమాచారం సమాచారం అన్వేషణను రికార్డ్ చేయటానికి ఉపయోగించబడింది. సమాచారం దొరకినప్పుడు, bFound యొక్క విలువ తప్పక సమాచారం ఉంటుంది, !bFound సమాచారం తప్పక సమాచారం ఉంటుంది, అందువలన నడుము సైకిల్ లోకి నడుము విడిచిపోతుంది.

ఎక్మాస్క్రిప్ట్ వేరీయాబుల్ బౌల్ విలువను తనిఖీ చేయటంలో కూడా లాజికల్ నాట్ ఆపరేటర్ ఉపయోగించవచ్చు. ఇది చేయటం కోసం ఒక పంక్తిలో రెండు NOT ఆపరేటర్స్ ఉపయోగించాలి. ఏ రకమైన ఆపరేండ్ ఉంటుంది అయినా, మొదటి NOT ఆపరేటర్ బౌల్ విలువను తిరిగిస్తుంది. రెండవ NOT ఆపరేటర్ బౌల్ విలువను పక్కాణిస్తుంది, అందువలన వాస్తవమైన బౌల్ విలువను తెలుపుతుంది.

var bFalse = false;
var sRed = "red";
var iZero = 0;
var iThreeFourFive = 345;
var oObject = new Object;
document.write("bFalse యొక్క లాజికల్ విలువ ఉంది " + (!!bFalse));
document.write("sRed యొక్క లాజికల్ విలువ ఉంది " + (!!sRed));
document.write("iZero యొక్క లాజికల్ విలువ ఉంది " + (!!iZero));
document.write("iThreeFourFive యొక్క లాజికల్ విలువ ఉంది " + (!!iThreeFourFive));
document.write("oObject యొక్క లాజికల్ విలువ ఉంది " + (!!oObject));

结果：

bFalse 的逻辑值是 false
sRed 的逻辑值是 true
iZero యొక్క లాజికల్ విలువ ఫాల్స్ ఉంది
iThreeFourFive యొక్క లాజికల్ విలువ ట్రూ ఉంది
oObject యొక్క లాజికల్ విలువ ట్రూ ఉంది

లాజికల్ AND ఆపరేషన్ సిగ్న్

ECMAScript లో, లాజికల్ AND ఆపరేషన్ డబల్ అండ్ సిగ్న్ ఉపయోగించబడుతుంది:

例如：

var bTrue = true;
var bFalse = false;
var bResult = bTrue && bFalse;

లాజికల్ AND ఆపరేషన్ ప్రతిక్రియను వర్ణించే నిజాంకిత పట్టిక క్రింద ఉంది:

运算数 1 运算数 2 结果
true true true
true false false
false true false
false false false

లాజికల్ AND ఆపరేషన్ ఆపరేషన్లు ఏ రకమైనా ఉండవచ్చు, కానీ బౌలియన్ విలువలు కాదు.

ఏదైనా ఆపరేషన్ ప్రాథమిక బౌలియన్ విలువ కాదు ఉన్నప్పుడు, లాజికల్ AND ఆపరేషన్ బౌలియన్ విలువ ఉండదు అని నిర్ణయించబడదు:

  • ఏదైనా ఆపరేషన్ ఆబ్జెక్ట్ ఉన్నప్పుడు మరియు మరొకటి బౌలియన్ విలువ ఉన్నప్పుడు, ఆబ్జెక్ట్ ఉంటుంది.
  • రెండు ఆపరేషన్లు ఆబ్జెక్ట్లు ఉన్నప్పుడు, రెండవ ఆబ్జెక్ట్ ఉంటుంది.
  • ఏదైనా ఆపరేషన్ నెలకొనబడని ఉంటే, నెలకొనబడని ఉంటుంది.
  • ఏదైనా ఆపరేషన్ నాన్ నామ్ ఉన్నప్పుడు, నాన్ నామ్ ఉంటుంది.
  • 如果某个运算数是 undefined，发生错误。

జావాలో లాజికల్ AND ఆపరేషన్‌తో పరిమితంగా, ECMAScript లో లాజికల్ AND ఆపరేషన్ కూడా సులభమైన ఆపరేషన్, అది అనుకూలించబడిన ఆపరేషన్, అనగా మొదటి ఆపరేషన్ ఫలితాన్ని నిర్ణయించినప్పుడు రెండవ ఆపరేషన్ గణించబడదు. లాజికల్ AND ఆపరేషన్ కొరకు, మొదటి ఆపరేషన్ ఫాల్స్ ఉన్నప్పుడు, రెండవ ఆపరేషన్ యొక్క విలువ ఏమైనా ఫలితం ట్రూ కాదు.

ఈ ఉదాహరణను పరిగణించండి:

var bTrue = true;
var bResult = (bTrue && bUnknown);	//విఫలం జరుగుతుంది
alert(bResult);			//ఈ వరుస అమలు కాదు

ఈ కోడ్ లాజికల్ AND ఆపరేషన్ చేయడంలో విఫలం జరుగుతుంది, బియున్క్నాల్స్ వివరణనిష్పత్తి ఉన్నందున. బియున్క్నాల్స్ వివరణనిష్పత్తి ఉన్నప్పటికీ లాజికల్ AND ఆపరేషన్ కొనసాగుతుంది బియున్క్నాల్స్ వివరణనిష్పత్తి ఉన్నందున ఇది విఫలం జరుగుతుంది, బియున్క్నాల్స్ వివరణనిష్పత్తి ఉన్నందున అది లాజికల్ AND ఆపరేషన్ కొనసాగుతుంది.

ఈ ఉదాహరణను మార్చి మొదటి సంఖ్యను ఫాల్స్ చేసినప్పుడు, విఫలం జరగదు:

var bFalse = false;
var bResult = (bFalse && bUnknown);
alert(bResult);			//ఫాల్స్ అవుట్‌పుట్

ఈ కోడ్‌లో, స్క్రిప్ట్ లాజికల్ AND ఆపరేషన్ ఫలితాన్ని అవుట్‌పుట్ చేస్తుంది, అది స్ట్రింగ్ "ఫాల్స్". బియున్క్నాల్స్ వివరణనిష్పత్తి ఉన్నప్పటికీ, మొదటి ఆపరేషన్ ప్రమాణం ఫాల్స్ ఉండినందున అది గణించబడదు.

提示：在使用逻辑 AND 运算符时，必须记住它的这种简便计算特性。

逻辑 OR 运算符

ECMAScript 中的逻辑 OR 运算符与 Java 中的相同，都由双竖线（||）表示：

var bTrue = true;
var bFalse = false;
var bResult = bTrue || bFalse;

下面的真值表描述了逻辑 OR 运算符的行为：

运算数 1 运算数 2 结果
true true true
true false true
false true true
false false false

与逻辑 AND 运算符相似，如果某个运算数不是 Boolean 值，逻辑 OR 运算并不一定返回 Boolean 值：

  • 如果一个运算数是对象，并且该对象左边的运算数值均为 false，则返回该对象。
  • 如果两个运算数都是对象，返回第一个对象。
  • 如果最后一个运算数是 null，并且其他运算数值均为 false，则返回 null。
  • 如果最后一个运算数是 NaN，并且其他运算数值均为 false，则返回 NaN。
  • 如果某个运算数是 undefined，发生错误。

与逻辑 AND 运算符一样，逻辑 OR 运算也是简便运算。对于逻辑 OR 运算符来说，如果第一个运算数值为 true，就不再计算第二个运算数。

例如：

var bTrue = true;
var bResult = (bTrue || bUnknown);
alert(bResult);			//输出 "true"

与前面的例子相同，变量 bUnknown 是未定义的。不过，由于变量 bTrue 的值为 true，bUnknown 不会被计算，因此输出的是 "true"。

బాగా bTrue ని false చేసినప్పుడు పరిణామం ఉంది:

var bFalse = false;
var bResult = (bFalse || bUnknown);	// పరిణామం ఉంది
alert(bResult);			// ఈ పదం పని చేయదు