Umfassendes Verständnis von Javascript-Operatoren und logischen Operatoren

Vorherige Wörter
Logischer Operator führt boolesche Operationen an Operanden aus und wird häufig in Verbindung mit relationalen Operatoren verwendet. Logische Operatoren kombinieren mehrere relationale -Ausdrücke , um einen komplexeren Ausdruck zu bilden. Logische Operatoren werden in drei Typen unterteilt: logisches NICHT „!“, logisches UND „&&“ und logisches ODER „||“. In diesem Artikel werden diese drei logischen Operatoren
logisches NICHT
vorgestellt logisch Der Nicht--Operator wird durch ein Ausrufezeichen (!) dargestellt und kann auf jeden Wert in ECMAScript angewendet werden. Dieser Operator gibt einen booleschen Wert zurück, unabhängig vom Datentyp des Werts. Der logische NOT-Operator wandelt seinen Operanden zunächst in einen booleschen Wert um und negiert ihn dann
Der logische NOT-Operator wird in einen booleschen Typ Konvertierungstyp und eine Boolean()-Konvertierung Funktion ist das Gleiche, außer dass das Ergebnis am Ende invertiert wird. Und wenn Sie zwei logische NOT-Operatoren gleichzeitig verwenden, wird tatsächlich das Verhalten der Boolean()-Transformationsfunktion

console.log(!!undefined);//false
console.log(!!null);//false
console.log(!!0);//false
console.log(!!-0);//false
console.log(!!NaN);//false
console.log(!!'');//false
console.log(!!false);//false

console.log(!!{});//true
console.log(!![]);//true

console.log(!!new Boolean(false));//true
console.log(!!false);//false
console.log(!!new Boolean(null));//true
console.log(!!null);//false

Logischer NICHT-Operator
wird häufig zur Steuerung von Schleifen verwendet

//Boolean 变量(bFound)用于记录检索是否成功。找到问题中的数据项时，bFound 将被设置为true，!bFound将等于false，意味着运行将跳出while循环
var bFound = false;
var i = 0;
while (!bFound) {
 if (aValue[i] == vSearchValues) {
  bFound = true;
 } else {
  i++;
 }
}

Logische UND-Verknüpfung Das Symbol
wird durch zwei kaufmännische Und-Zeichen (&&) dargestellt und hat zwei Operanden. Nur wenn beide Operanden wahr sind, gibt das Ergebnis „true“ zurück, andernfalls gibt es „false“ zurück

//逻辑与(&&)的真值表
第一个操作数    第二个操作数    结果
true       true        true
true       false       false
false       true        false
false       false       alse

Die logische UND-Verknüpfung ist eine Kurzschlussoperation. Wenn der erste Operand das Ergebnis bestimmen kann, dann Der zweite Operand wird nicht ausgewertet.

Wenn bei logischem UND der erste Operand falsch ist, ist das Ergebnis unabhängig vom Wert des zweiten Operanden falsch Der erste Operand ist wahr, dann ist der wahre oder falsche Wert des Ergebnisses derselbe wie der wahre oder falsche Wert des zweiten Operanden. Dann wird der zweite Operand zurückgegeben

//除了false、undefined、null、+0、-0、NaN、''这7个假值，其余都是真值
console.log('t' && ''); //因为't'是真值，所以返回''
console.log('t' && 'f'); //因为't'是真值，所以返回'f'
console.log('t' && 1 + 2); //因为't'是真值，所以返回3
console.log('' && 'f'); //因为''是假值，所以返回''
console.log('' && ''); //因为''是假值，所以返回''

var i = 1;
var result = (true && i++);
console.log(result,i);//因为true是真值，所以执行i++，i是2，result是1

var i = 1;
var result = (false && i++);
console.log(result,i);//因为false是假值，所以不执行i++，i是1，result是false

console.log(true && 'foo' && '' && 4 && 'foo' && true);// ''

Priorität des Operators Ebene
hat eine höhere Priorität als logisches UND (&&) und logisches ODER (||), daher können ähnliche Ausdrücke direkt geschrieben werden, ohne Klammern hinzuzufügen

if(a+1==2 && b+2==3){
  //Todo  
}

if (a == b) {
 doSomething();
}
// 等价于
(a == b) && doSomething();

//若没有给参数a传值，则a为默认的undefined，是假值，所以不执行a()，防止报错，如果给参数a传值，则执行函数a()
function fn(a){
  if(a){
    a();
  }
}
//等价于
function fn(a){
  a && a();
}

Der logische ODER-Operator
wird durch zwei vertikale Balken (||) dargestellt und hat zwei Operanden. Das Ergebnis gibt nur dann „false“ zurück, andernfalls wird „true“ zurückgegeben
In ähnlicher Weise kann die logische ODER-Verknüpfung auch auf jede Art von Operanden angewendet werden, nicht nur auf boolesche Werte. Wenn einer der Operanden kein boolescher Wert ist, gibt die logische ODER-Verknüpfung nicht unbedingt einen booleschen Wert zurück

//逻辑或(||)的真值表
第一个操作数    第二个操作数    结果
true       true       true
true       false       true
false       true       true
false       false       false

console.log('t' || '');//因为't'是真值，所以返回"t"
console.log('t' || 'f');//因为't'是真值，所以返回"t"
console.log('' || 'f');//因为''是假值，所以返回"f"
console.log('' || '');//因为''是假值，所以返回""

Ähnlich kann der logische ODER-Operator auch in mehreren Kombinationen verwendet werden, um den Wert des ersten Ausdrucks zurückzugeben, dessen boolescher Wert wahr ist

var i = 1;
var result = (true || i++);
console.log(result,i);//因为true是真值，所以不执行i++，result是true，i是1

var i = 1;
var result = (false || i++);
console.log(result,i);//因为false是假值，所以执行i++，i是2，result是1

Der logische Der OR-Operator wird häufig verwendet. Standardwert für Variable festlegen

console.log(false || 0 || '' || 4 || 'foo' || true);// 4

//如果没有向参数p传入任何对象，则将该参数默认设置为空对象
function fn(p){
  p = p || {};
}

Das obige ist der detaillierte Inhalt vonUmfassendes Verständnis von Javascript-Operatoren und logischen Operatoren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!