Y a-t-il une différence entre OUI / NON, VRAI / FAUX et vrai / faux dans objective-c?

Question simple vraiment; Y a-t-il une différence entre ces valeurs (et y a-t-il une différence entre BOOL et bool)? Un collègue a mentionné qu’ils évaluaient différentes choses dans Objective-C, mais lorsque j’ai examiné les typedefs dans leurs fichiers .h respectifs, YES / TRUE / true étaient tous définis comme 1 et NO / FALSE / false étaient tous définis comme 0 . Y a-t-il vraiment une différence?

Il n’y a pas de différence pratique à condition d’utiliser des variables BOOL comme booléens. C traite des expressions booléennes selon qu’elles sont évaluées à 0 ou non 0. Donc:

 if(someVar ) { ... } if(!someVar) { ... } 

signifie la même chose que

 if(someVar!=0) { ... } if(someVar==0) { ... } 

c’est pourquoi vous pouvez évaluer n’importe quel type ou expression primitif en tant que test booléen (y compris, par exemple, les pointeurs). Notez que vous devriez faire le premier, pas le dernier.

Notez qu’il y a une différence si vous affectez des valeurs obtuses à une variable BOOL et testez des valeurs spécifiques. Utilisez-les donc toujours comme des booléens et affectez-les uniquement à leurs valeurs #define .

Surtout, ne testez jamais les booléens en utilisant une comparaison de caractères – ce n’est pas seulement risqué car on peut atsortingbuer à someVar une valeur différente de zéro, ce qui n’est pas OUI, mais, à mon avis,

 if(someVar==YES) { ... } // don't do this! if(someVar==NO ) { ... } // don't do this either! 

En d’autres termes, utilisez des concepts tels qu’ils sont prévus et documentés pour être utilisés et vous vous épargnerez un monde de souffrance en C.

Je crois qu’il y a une différence entre bool et BOOL , consultez cette page Web pour savoir pourquoi:
http://iosdevelopertips.com/objective-c/of-bool-and-yes.html

BOOL étant un caractère unsigned char plutôt qu’un type primitif, les variables de type BOOL peuvent contenir des valeurs autres que YES et NO .

Considérez ce code:

 BOOL b = 42; if (b) { printf("b is not NO!\n"); } if (b != YES) { printf("b is not YES!\n"); } 

La sortie est la suivante:

b n’est pas NON!
b n’est pas OUI!

Pour la plupart des gens, il s’agit d’une préoccupation inutile, mais si vous voulez vraiment un booléen, il est préférable d’utiliser un bool . Je devrais append: le SDK iOS utilise généralement BOOL sur ses définitions d’interface, c’est un argument à suivre avec BOOL .

J’ai fait un test exhaustif à ce sujet. Mes résultats devraient parler d’eux-mêmes:

 //These will all print "1" NSLog(@"%d", true == true); NSLog(@"%d", TRUE == true); NSLog(@"%d", YES == true); NSLog(@"%d", true == TRUE); NSLog(@"%d", TRUE == TRUE); NSLog(@"%d", YES == TRUE); NSLog(@"%d", true == YES); NSLog(@"%d", TRUE == YES); NSLog(@"%d", YES == YES); NSLog(@"%d", false == false); NSLog(@"%d", FALSE == false); NSLog(@"%d", NO == false); NSLog(@"%d", false == FALSE); NSLog(@"%d", FALSE == FALSE); NSLog(@"%d", NO == FALSE); NSLog(@"%d", false == NO); NSLog(@"%d", FALSE == NO); NSLog(@"%d", NO == NO); //These will all print "0" NSLog(@"%d", false == true); NSLog(@"%d", FALSE == true); NSLog(@"%d", NO == true); NSLog(@"%d", false == TRUE); NSLog(@"%d", FALSE == TRUE); NSLog(@"%d", NO == TRUE); NSLog(@"%d", false == YES); NSLog(@"%d", FALSE == YES); NSLog(@"%d", NO == YES); NSLog(@"%d", true == false); NSLog(@"%d", TRUE == false); NSLog(@"%d", YES == false); NSLog(@"%d", true == FALSE); NSLog(@"%d", TRUE == FALSE); NSLog(@"%d", YES == FALSE); NSLog(@"%d", true == NO); NSLog(@"%d", TRUE == NO); NSLog(@"%d", YES == NO); 

La sortie est la suivante:

 2013-02-19 20:30:37.061 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.061 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.072 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.073 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.073 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.074 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.074 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.075 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.075 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.076 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.077 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.077 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.078 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.078 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.079 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.079 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.080 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.080 BooleanTests[27433:a0f] 1 2013-02-19 20:30:37.081 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.081 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.082 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.091 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.092 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.093 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.093 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.094 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.094 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.095 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.095 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.096 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.096 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.097 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.098 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.101 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.102 BooleanTests[27433:a0f] 0 2013-02-19 20:30:37.102 BooleanTests[27433:a0f] 0 

Vous voudrez peut-être lire les réponses à cette question . En résumé, dans Objective-C (de la définition dans objc.h):

 typedef signed char BOOL; // BOOL is explicitly signed so @encode(BOOL) == "c" rather than "C" // even if -funsigned-char is used. #define OBJC_BOOL_DEFINED #define YES (BOOL)1 #define NO (BOOL)0 

La principale (dangereuse!) Différence entre true et YES réside dans la sérialisation JSON.

Par exemple, nous avons une requête de serveur de type JSON et nous devons envoyer true / false dans json sence:

 NSDictionary *r1 = @{@"bool" : @(true)}; NSDictionary *r2 = @{@"bool" : @(YES)}; NSDictionary *r3 = @{@"bool" : @((BOOL)true)}; 

Ensuite, nous le convertissons en chaîne JSON avant de l’envoyer comme

 NSData *data = [NSJSONSerialization dataWithJSONObject:requestParams options:0 error:nil]; NSSsortingng *jsonSsortingng = [[NSSsortingng alloc] initWithData:data encoding:NSUTF8SsortingngEncoding]; 

Le résultat est

 jsonSsortingng1 // {"bool":1} jsonSsortingng2 // {"bool":true} jsonSsortingng3 // {"bool":true} 

En raison de la logique API, jsonSsortingng1 pourrait entraîner une erreur.

Alors faites attention aux booléens en Objective-C.

PS Vous pouvez utiliser

 @{@"bool" : @"true"}; // {"bool":true} 

Je pense qu’ils ajoutent OUI / NON pour être plus explicite dans de nombreux cas. Par exemple:

 [button setHidden:YES]; 

sonne mieux que

 [button setHidden:TRUE]; 

Il y a un bug subtil que personne n’a mentionné ici, que je pensais inclure … plus d’une erreur logique que tout:

 int i = 2; if(i); //true if(i==YES); // false if((!!i)==YES); //true 

le problème ici est juste que (YES==1) et dans C la comparaison n’est pas booléenne, mais basée sur la valeur.

Parce que YES est juste un #define (plutôt que quelque chose d’insortingnsèque au langage), il doit y avoir une certaine valeur, et 1 est le plus logique.

Examinons d’abord ce qu’est le vrai et le faux et ce qui leur donne un sens en premier lieu.

on peut construire une structure appelée si alors b else c dans lambda calcul comme suit:

 (\ifThenElse. )(\a. \b. \c. abc) 

En JavaScript, ceci ressemble à ceci:

 (function(ifThenElse) { // use ifThenElse })(function(a) { return function(b) { return function(c) { return a(b)(c); }; }; }); 

Pour que ifThenElse soit utile, nous avons besoin d’une fonction “true” qui choisit soit à droite soit à gauche, en ignorant l’autre option, ou une fonction “false” qui choisit l’option “true” ne prend pas.

Nous pouvons définir ces fonctions comme suit:

 (\true. )(\a. \b. a) and (\false. )(\a. \b. b) 

en JavaScript, il ressemble à ceci:

 (function(True) { // use True })(function(a) { return function(b) { return a; } }); (function(False) { // use True })(function(a) { return function(b) { return b; } }); 

maintenant nous pouvons faire ce qui suit

 (\true. \false. \ifThenElse. \doThis. \doThat. ifThenElse true doThis doThat) (\a. \b. a)(\a. \b. b)(\a. \b. \c. abc)(\a. ())(\a. ()) 

avec doThis et doQuand (\ a. ()) parce que lambda calcul n’offre pas de services tels que l’impression / math / les chaînes, tout ce que nous pouvons faire, c’est ne rien faire et dire que nous l’avons fait notre système qui fournit des effets secondaires que nous voulons)

alors voyons cela en action.

 (function(True) { return (function(False) { return (function(ifThenElse) { return (function(doThis) { return (function(doThat) { return ifThenElse(True)(doThis)(doThat); }); }); }); }) })(function(a) { return function(b) { return a; } })(function(a) { return function(b) { return b; } })(function(a) { return function(b) { return function(c) { return a(b)(c); }; }; })(function(a) { console.log("you chose LEFT!"); }) (function(a) {console.log("you chose RIGHT");})(); 

C’est un environnement profond qui pourrait être simplifié si on était autorisé à utiliser des tableaux / cartes / arguments / ou plusieurs instructions à diviser en plusieurs fonctions, mais je veux garder est aussi pur que je peux me limiter aux fonctions d’un seul argument seulement.

Notez que le nom True / False n’a aucune signification inhérente, nous pouvons facilement les renommer en oui / non, gauche / droite, droite / gauche, zéro / un, pomme / orange. Cela a un sens dans la mesure où quel que soit le choix fait, il est seulement causé par le genre de sélecteur fait. Donc, si “LEFT” est imprimé, nous soaps que le sélecteur ne peut être vrai, et sur la base de ces connaissances, nous pouvons guider nos décisions ultérieures.

Donc pour résumer

 function ChooseRight(left) { return function _ChooseRight_inner(right) { return right; } } function ChooseLeft(left) { return function _ChooseLeft_inner(right) { return left; } } var env = { '0': ChooseLeft, '1': ChooseRight, 'false': ChooseRight, 'true': ChooseLeft, 'no': ChooseRight 'yes': ChooseLeft, 'snd': ChooseRight, 'fst': ChooseLeft }; var _0 = env['0']; var _1 = env['1']; var _true = env['true']; var _false = env['false']; var yes = env['yes']; var no = env['no']; // encodes church zero or one to boolean function lambda_encodeBoolean(self) { return self(false)(true); } // decodes a Boolean to church zero or one function lambda_decodeBoolean(self) { console.log(self, self ? env['true'] : env['false']); return self ? env['true'] : env['false']; } lambda_decodeBoolean('one' === 'two')(function() { console.log('one is two'); })(function() { console.log('one is not two'); })(); lambda_decodeBoolean('one' === 'one')(function() { console.log('one is one'); })(function() { console.log('one is not one'); })(); 

Non, OUI / NON est une manière différente de faire référence à VRAI / FAUX (1/0)