# Analisi del Codice

**URL:** <https://it.discourse.mcneel.com/t/analisi-del-codice/4935>\
**Category:** Scripting e Programmazione\
**Created:** [7 Febbraio 2023, 10:27pm UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935 "2023-02-07T22:27:32Z")\
**Posts on this page:** 20\
**Page:** 3

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [17 Febbraio 2023, 3:25pm UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/41 "2023-02-17T15:25:55Z")

</div>

> [@emilio](#):
>
> Utilizzare o meno una enum per operazioni sui bit e’ questione di logica del programma.  
> Cioe’ come tu strutturi il programma affinche’ faccia quello che serve.  
> Le operazioni che tu decidi di fare nel tuo script.
> 
> La sintassi del C# non c’entra. Non c’e’ nessuna regola che ti obblighi a usare le operazioni sui bit con le enum.  
> Semplicemente lo fai se ti sembra l’operazione giusta da fare.

ok siamo daccordo, ma se non si conosce bene il funzionamento  
di una funziona, come si fa a valutare se è più adatta di un’altra?

> [@Sergio\_Alessi](#):
>
> int filtro = Point | PointSet | Curve;

> [@Sergio\_Alessi](#):
>
> a = Point;  
> res= a & filtro; // restituisce 1 =\> vero

parentesi bit a parte  
nell’esempio di Sergio abbiamo la variabile Point che equivale a 1  
alla riga successiva invece, c’é **res = a & filtro** con risultato di 1

per quanto mi riguarda e come scrivere (res = a se a corrisponde ad uno dei valori di filtro)  
in questo caso il ragionamento è corretto oppure sono fuori strada?

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [17 Febbraio 2023, 4:53pm UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/42 "2023-02-17T16:53:44Z")

</div>

> [@0904](#):
>
> (res = a se a corrisponde ad uno dei valori di filtro)

Esatto

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [17 Febbraio 2023, 5:49pm UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/43 "2023-02-17T17:49:41Z")

</div>

> [@emilio](#):
>
> > [@0904](#):
> >
> > (res = a se a corrisponde ad uno dei valori di filtro)
> 
> Esatto

ma quello che mi sfugge è: le operazioni che vengono eseguite con questa funziona sono identiche  
alla sintassi di un **if** oppure il risultato è identico ma lo svolgimento è come indicato da Sergio?

> [@Sergio\_Alessi](#):
>
> Point =1 // 0001  
> PointSet=2 //0010  
> Curve =4 // 0100  
> Surface=8 // 1000
> 
> La variabile filtro combina i valori con operatore or (regole tra bit: 0|0=0 1|0=1 0|1=1 1|1=1)  
> filtro = 7 // 0001 | 0010 = 0011 | 0100 = 0111  
> a=8 //1000 (surface)  
> L’operatore & (regole tra bit: 0&0=0 1&0=0 0&1=0 1&1=1)  
> res = a & filtro // 1000 & 0111 = 0  
> Se invece a = Curve, valore binario 0100  
> res = a & filtro // 0 **1** 00 & 0 **1** 11 = 0100 diverso tra 0 =\> vero!

perché da quello che ho capito, è come se questa funzione trasforma in numeri i valori delle variabili le combina e le compara tra di loro, e se è questo ciò che accade, anche capendo sommariamente cosa si svolge dietro le quinte non mi è facile pensare ad una soluzione usando questa funzione con il ragionamento binario come postato sopra tipo: **filtro = 7 // 0001 | 0010 = 0011 | 0100 = 0111**

> [@emilio](#):
>
> Tra l’altro, non so come fai a imparare qualcosa da quelle pagine.  
> La traduzione automatica e’ terrificante …

concordo infatti vado a verificare solo gli esempi e cerco di estrapolare qualcosa di buono  
ma non credo che sia una guida per chi deve imparare ma giusto un riepilogo per chi già sa.  
giusto per capire meglio come funzionasse la combinazione degli 0 e 1 tra di loro

ps ma in questa riga: **filtro = 7 // 0001 | 0010 = 0011 | 0100 = 0111**  
forse sbaglio ma a me sembra che il risultato di ogni or (|) si compara con il valore successivo  
0001 | 0010 risultato 0011 e quest’ultimo si va a comparare con 0100 che poi ritorna 0111 è corretto?

che poi la comparazione con or (|) in questo caso non’é una vera comparazione ma diventa una combinazione tra un valore e l’altro che **poi** porta il risultato finale da “analizzare” (sempre se è così)

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [18 Febbraio 2023, 12:24am UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/44 "2023-02-18T00:24:47Z")

</div>

> [@0904](#):
>
> lo svolgimento è come indicato da Sergio?

Si’, e’ come dice Sergio.

> [@0904](#):
>
> trasforma in numeri i valori delle variabili le combina e le compara tra di loro

Quando tu usi una variabile o una enum, il linguaggio per fare i calcoli utilizza il valore corrispondente.  
Per una enum quel valore e’ sempre un intero.

Gli operatori **and** (&) e **or** (|) per i bit eseguono la relativa operazione logica: AND oppure OR.  
Che sono quelle mostrate da Sergio.

> [@Sergio\_Alessi](#):
>
> or (regole tra bit: 0|0=0 1|0=1 0|1=1 1|1=1)  
> & (regole tra bit: 0&0=0 1&0=0 0&1=0 1&1=1)

Combinare o comparare sono nostre interpretazioni di quelle operazioni.  
Cioe’ capita che nello script utilizziamo gli operatori logici per i bit per comparare o combinare dei valori.  
Ma quello che fa il computer e’ sempre e solo eseguire semplicemente la relativa operazione logica sui bit. Cioe’ applica le regole riportate sopra.

> [@0904](#):
>
> non mi è facile pensare ad una soluzione usando questa funzione

Una soluzione per cosa ? 🙂

> [@0904](#):
>
> ps ma in questa riga: **filtro = 7 // 0001 | 0010 = 0011 | 0100 = 0111**  
> forse sbaglio ma a me sembra che il risultato di ogni or (|) si compara con il valore successivo  
> 0001 | 0010 risultato 0011 e quest’ultimo si va a comparare con 0100 che poi ritorna 0111 è corretto?

Si’, Sergio intendeva mostrare il risultato della operazione ‘composta’ **0001 | 0010 | 0100** e la ha scomposta in due passaggi.

> [@0904](#):
>
> che poi la comparazione con or (|) in questo caso non’é una vera comparazione ma diventa una combinazione tra un valore e l’altro che **poi** porta il risultato finale da “analizzare” (sempre se è così)

E’ quello che dicevamo sopra: noi possiamo interpretarla come una comparazione, ma in realta’ il computer esegue semplicemente una **or** sui bit.

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [18 Febbraio 2023, 12:46am UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/45 "2023-02-18T00:46:17Z")

</div>

premessa per la cronaca, mi sono andato anche a guardare dei tutorial binary/decimal

> [@emilio](#):
>
> E’ quello che dicevamo sopra: noi possiamo interpretarla come una comparazione, ma in realta’ il computer esegue semplicemente una **or** sui bit.

giusto per chiarire bene: che i pc comunicano con il linguaggio binario ovviamente questo è lapalissiano  
ma l’esempio che ha fatto Sergio, l’ha fatto perché la funzione **enum** si prestava bene a far capire il concetto di come poi viene tradotto dal computer oppure **è quello che la funzione va a fare lei stessa?**  
(per questo ho aperto questa digressione perché avevo +/- inteso che era un qualcosa che faceva **enum** )

quindi una cosa era che usando **enum** scrivo: Lun = 1 / Mar = 2 ecc ecc e tutto finisce li va bene  
tutt’altro invece per usare bene **enum** nei vari contesti debbo capire i numeri binari che ci stanno dietro

* * *

> [@emilio](#):
>
> Una soluzione per cosa ? 🙂

es: (se fuori piove; PortareOmbrello = si)  
se dovrei ragionare seguendo l’esempio di Sergio coi numeri binari, mi sarebbe un pochino complicato. . .

---

<div class="post-metadata">

**Author:** ![Sergio\_Alessi](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/sergio_alessi/32/22676_2.png) [@Sergio\_Alessi](https://it.discourse.mcneel.com/u/Sergio_Alessi)\
**Post date:** [18 Febbraio 2023, 9:36am UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/46 "2023-02-18T09:36:59Z")

</div>

> [@0904](#):
>
> giusto per chiarire bene: che i pc comunicano con il linguaggio binario ovviamente questo è lapalissiano  
> ma l’esempio che ha fatto Sergio, l’ha fatto perché la funzione **enum** si prestava bene a far capire il concetto di come poi viene tradotto dal computer oppure **è quello che la funzione va a fare lei stessa?**

Ciao Salvio

le enum si utilizzano nel modo che ognuno di noi ritiene più opportuno.  
In un post facevi riferimento all’enumerazione delle entità geometriche  
nell’sdk di rhino. Con l’occasione ho cercato di evidenziare che la tecnica  
di enumerazione adottata rende certe elaborazioni molto efficienti in  
quanto, come chiarito da @emilio, è basata su operazioni logiche.  
La stessa tecnica di enumerazione ha come “limite” il numero di costanti  
definibili all’interno di una enumerazione.  
In una enumerazione bitwise basata su byte, 8bit, si possono definire  
al massimo 8 costanti. Analogamente se riferita ad un intero a 32 bit,  
si possono definire al massimo 32 costanti. E se un intero a 64 bit …  
ecc. ecc. ecc.

Se invece si adotta un approccio “tradizionale” nell’uso di enum il numero  
di costanti definibili aumenta in modo esponenziale!

Le enum non sono necessarie così come le costanti. Servono per rendere  
più semplice la codifica e possono semplificarti il lavoro riducendo gli  
errori di battitura.

Un’ultima osservazione: immagina gli esempi relativi all’sdk di rhino  
senza enumerazioni. Ho copiato un pezzo di codice riportato sopra  
inserendo valori a caso

```auto
    go = Rhino.Input.Custom.GetObject()
    go.SetCommandPrompt("Select closed planar curve")
    go.GeometryFilter = 2 
    go.GeometryAttributeFilter = 7
    go.SubObjectSelect = False
    go.Get()
    if go.CommandResult()!=4: return

...

Cosa capisci?

Ora confrontalo con questo ...

```

go = Rhino.Input.Custom.GetObject()  
go.SetCommandPrompt(“Select closed planar curve”)  
go.GeometryFilter = Rhino.DocObjects.ObjectType.Curve  
go.GeometryAttributeFilter = Rhino.Input.Custom.GeometryAttributeFilter.ClosedCurve  
go.SubObjectSelect = False  
go.Get()  
if go.CommandResult()!=Rhino.Commands.Result.Success: return

```auto

```

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [18 Febbraio 2023, 1:22pm UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/47 "2023-02-18T13:22:29Z")

</div>

ciao Sergio,  
eeee una bella domanda, a prima vista la spiegazione **mi** dovrebbe essere non complicata, cioè:

in entrambi gli esempi il codice si può dire identico, solo che nel primo usi il valore numerico,  
mentre nel secondo nei 2 Filter e Result usi il **Member name** per indicare le scelte  
volute essendo che in tutti e 3 casi si parla della funzione **enum** Enumeration

unica cosa che mi sfugge sono i valori numerici che non mi tornano, sopratutto il 7 ed il 4

ad esempio: Rhino.Commands.Result.Success equivale a 0 e non a 4

ps se l’intento era quello di postare

---

<div class="post-metadata">

**Author:** ![Sergio\_Alessi](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/sergio_alessi/32/22676_2.png) [@Sergio\_Alessi](https://it.discourse.mcneel.com/u/Sergio_Alessi)\
**Post date:** [18 Febbraio 2023, 2:19pm UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/48 "2023-02-18T14:19:49Z")

</div>

> [@0904](#):
>
> unica cosa che mi sfugge sono i valori numerici che non mi tornano, sopratutto il 7 ed il 4

> [@Sergio\_Alessi](#):
>
> Ho copiato un pezzo di codice riportato sopra  
> inserendo valori a caso

Non fare il fenomeno: Mi vuoi dire che nell’ipotesi di non aver mai letto la  
documentazione di rhino sdk i due codici hanno medesima leggibilità???  
… bhà.

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [18 Febbraio 2023, 2:31pm UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/49 "2023-02-18T14:31:12Z")

</div>

> [@Sergio\_Alessi](#):
>
> Non fare il fenomeno

fenomeno io. . . Sergio se si vanno a leggere i miei post si constatare perfettamente l’opposto

> [@Sergio\_Alessi](#):
>
> i due codici hanno medesima leggibilità???

ho riletto altre due volte i due codici, e il risultato è lo stesso, cambiano solo i 3 valori numerici  
messi nel primo, per il resto sono identici, quindi la differenza sta nell’inserimento dei parametri

poi se ci sono spiegazioni tecniche differenti dietro al codice scritto li puoi indicare, io non saprei.

> [@Sergio\_Alessi](#):
>
> Mi vuoi dire che nell’ipotesi di non aver mai letto la  
> documentazione di rhino sdk

però io qualcosina in VBS e Py credo di averle assimilate quindi un ragionamento sui codici lo faccio

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [20 Febbraio 2023, 12:35am UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/50 "2023-02-20T00:35:14Z")

</div>

ma quindi gli **enum** si potrebbero equiparare alle dictionary in python?

---

<div class="post-metadata">

**Author:** ![Sergio\_Alessi](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/sergio_alessi/32/22676_2.png) [@Sergio\_Alessi](https://it.discourse.mcneel.com/u/Sergio_Alessi)\
**Post date:** [20 Febbraio 2023, 10:01am UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/51 "2023-02-20T10:01:56Z")

</div>

NO!  
enum = gruppo di valori costanti.  
dictionary = “oggetto” con proprietà e metodi = mutevole in runtime.

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [20 Febbraio 2023, 11:14am UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/52 "2023-02-20T11:14:30Z")

</div>

> [@0904](#):
>
> gli **enum**

A suo tempo anch’io rimanevo confuso dagli enum (e da altro).  
Ma sono giunto alla conclusione che nei linguaggi ‘tipizzati’, chiamiamoli cosi’, certe feature servono piu’ che altro ad evitare errori (tipo dati sbagliato) nei progetti di grandi dimensioni, con decine o centinaia di programmatori, oltre ad essere un po’ piu’ veloci a volte.  
Allora compaiono cose come enum, costanti, private & public e forse altro …  
Cose che chi era abituato a linguaggi piu’ semplici, ‘non tipizzati’, fatica a capire … perche’ c’e’ veramente poco da capire. 😄  
Non sono cose come array o dizionari, che hanno una loro chiara utilita’.  
Sono cose di cui potremmo anche fare a meno, e infatti i linguaggi non tipizzati spesso ne fanno a meno.  
Nel caso delle enum, tu considerale (come ci ha spiegato Sergio), semplicemente un gruppo di costanti, volendo comprese nel loro piccolo namespace.  
Niente di piu’. Sono SOLO delle costanti.  
Se ci pensi, anche una costante non e’ indispensabile. Se usi una normale variabile il programma funziona esattamente allo stesso modo. 😀

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [20 Febbraio 2023, 2:20pm UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/53 "2023-02-20T14:20:08Z")

</div>

> [@Sergio\_Alessi](#):
>
> NO!  
> enum = gruppo di valori costanti.  
> dictionary = “oggetto” con proprietà e metodi = mutevole in runtime.

OK 👍

> [@emilio](#):
>
> A suo tempo anch’io rimanevo confuso dagli enum (e da altro).

> [@emilio](#):
>
> Cose che chi era abituato a linguaggi piu’ semplici, ‘non tipizzati’, fatica a capire … perche’ c’e’ veramente poco da capire. 😄  
> Non sono cose come array o dizionari, che hanno una loro chiara utilita’.

credo che come sempre non sono riuscito a spiegarmi, nell’uso superficiale degli **enum**  
sostanzialmente non credo di avere problemi, quello che invece non mi erano chiare sono due:

l’esempio postato da Sergio con i numeri binari, lo svolgimento spiegato con gli or (|) ecc  
(ma questo credo sia normale non avendoli mai utlizzati e credo non sia proprio un argomento soft  
e per questo al momento ritengo che sia meglio andarlo ad approfondirlo in seguito)

seconda cosa: il fatto che richiamando il suo valore numerico convertito in stringa riporti la descrizione:

(nel senso; e qui mi allaccio al fatto del perché li ho equiparati ai **dictonary** in Py o **Set/GetUserText** in  
Rhino, ovviamente questi due esempi sono da prendere in senso **lato** anche perché difficilmente  
credo che in un programma ci possono essere due funzioni simili ma mai completamente identiche)

la cosa in comune dei comandi citati con **enum** ad esempio vedo c’é un valore ed una chiave,  
ovviamente ognuna funziona a modo proprio, ma se mi serve sapere il valore in una dict  
vado a richiamare la chiave corrispondente come succede anche con GetUserText  
ma se voglio vedere le chiavi esistenti non debbo chiedere il valore ma la suddetta lista

mentre invece, in questo caso **enum** mi riporta ad esempio: “curve” valore testo  
se questo valore lo converto in int mi riporta il suo valore int corrispondente ad essa  
(non so se è chiaro adesso con questa spiegazione quello che a me non mi è chiaro)

altro es: ho una dict{1:“curve”}  
tramite la chiave 1 mi vado a richiamare il valore “curve” ad esso associato  
ma non’é che se faccio qualche altra operazione sul valore “curve” mi riporta la sua chiave  
per cercarmi la chiave debbo procedere di proposito per vedere le chiavi contenute nella dict

ovviamente **enum** funziona così, non sto contestando il suo funzionamento, ma essendo che questo  
tipo di meccanismo non mi è mai capitato quindi ignoro il suo funzionamento all’interno del suo codice.  
ripeto non’é per fare polemiche di nessun tipo, avevo solo visto un nuovo modo di esecuzione e mi ero  
**chiesto** il tutto come avvenisse tipo ha un **if** un **switch** un associazione qualsiasi che non conosco,  
che permetta usando **enum** di riportare il numerico 4 quando converto in int il valore di stringa “curve”

riassumendo come usare **enum** è chiaro, se poi per capire quanto appena descritto sopra, debbo prima conoscere il funzionamento cosa fa **enum** coi numeri binari (per questo Sergio aveva postato l’esempio)  
è un conto, in questo caso, come già detto dovrò prima approfondire questo discorso prima di riprenderlo.

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [20 Febbraio 2023, 2:28pm UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/54 "2023-02-20T14:28:14Z")

</div>

> [@0904](#):
>
> meglio andarlo ad approfondirlo in seguito

Concordo.  
Quando vuoi vediamo poi i bit, ma senza le enum ! 😉

> [@0904](#):
>
> il fatto che richiamando il suo valore numerico convertito in stringa riporti la descrizione:

Cosa intendi ?  
Puoi fare un esempio ?

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [20 Febbraio 2023, 2:33pm UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/55 "2023-02-20T14:33:27Z")

</div>

> [@emilio](#):
>
> Cosa intendi ?  
> Puoi fare un esempio ?

sorry, qui ho invertito il risultato di **enum**  
essendo che, il risultato è una stringa ma come mi facessi vedere, poi con int viene convertito in numero

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [20 Febbraio 2023, 2:36pm UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/56 "2023-02-20T14:36:52Z")

</div>

> [@emilio](#):
>
> Concordo.  
> Quando vuoi vediamo poi i bit, ma senza le enum ! 😉

ok allora prossimamente 👍

meglio però aprire una 3d dedicato se no un post non finisce mai 😉

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [20 Febbraio 2023, 2:38pm UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/57 "2023-02-20T14:38:29Z")

</div>

> [@0904](#):
>
> essendo che, il risultato è una stringa ma come mi facessi vedere, poi con int viene convertito in numero

Esempio, per favore …

> [@0904](#):
>
> aprire una 3d dedicato

Certamente.

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [20 Febbraio 2023, 3:11pm UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/58 "2023-02-20T15:11:45Z")

</div>

> [@0904](#):
>
> sorry, qui ho invertito il risultato di **enum**  
> essendo che, il risultato è una stringa ma come mi facessi vedere, poi con int viene convertito in numero

> [@emilio](#):
>
> Esempio, per favore …

* * *

> [@0904](#):
>
> ma mi ritorna la scritta **Curve** come output, come faccio a stampare il valore 4 ad esso associato?

> [@emilio](#):
>
> `int( tipo_oggetto )`

* * *

[https://developer.rhino3d.com/api/RhinoCommon/html/T\_Rhino\_DocObjects\_ObjectType.htm](https://developer.rhino3d.com/api/RhinoCommon/html/T_Rhino_DocObjects_ObjectType.htm)

a scusa credevo fosse associato che l’approfondimento degli **enum** è partita proprio da questo 3d dopo il post 22 dove poco prima come citato sopra mi avevi fatto vedere come convertire il risultato “curve” in int 4

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [20 Febbraio 2023, 3:57pm UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/59 "2023-02-20T15:57:24Z")

</div>

> [@0904](#):
>
> il risultato è una stringa ma come mi facessi vedere, poi con int viene convertito in numero

Quindi la cosa poco chiara e’ il fatto che la conversione in stringa restituisce il **Member name** anziche’ il **value**. Come da:  
[ObjectType Enumeration (rhino3d.com)](https://developer.rhino3d.com/api/RhinoCommon/html/T_Rhino_DocObjects_ObjectType.htm)

Personalmente, la penso sempre allo stesso modo:

> [@emilio](#):
>
> Quando serve convertire, ad esempio, in **int** o in **string** , il linguaggio applica le sue regole a seconda del tipo di dati, per cui otteniamo quanto si vede nelle ultime 2 colonne
> 
> ```auto
> variabile tipo valore str() int()
> a | ObjectType | 4 | 'Curve' | 4
> b | int | 8 | '8' | 8
> c | string | "Line" | 'Line' | ERRORE
> 
> ```

Cioe’, e’ semplicemente una regola del linguaggio: se converti un valore **enum** in stringa, ottieni il nome.  
A seconda dei casi, cio’ puo’ essere comodo o meno. Se invece ti serve il valore, usi **int()**.

> [@0904](#):
>
> mi ero  
> **chiesto** il tutto come avvenisse tipo ha un **if** un **switch** un associazione qualsiasi che non conosco,

Se parli dei bit, ne riparliamo in altra sede (anche se Sergio ha gia’ detto come funziona).  
Se l’altra cosa poco chiara e’ che tu nello script scrivi il nome e il linguaggio utilizza il valore…  
non e’ diverso da quanto succede per le variabili.

> [@0904](#):
>
> usando **enum** di riportare il numerico 4 quando converto in int il valore di stringa “curve”

Questo non e’ esatto.  
Se tu converti un valore **enum** in intero, ottieni un numero.  
Se tu provi a convertire in intero una stringa con scritto “Curve”, ottieni solo un errore.

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [20 Febbraio 2023, 4:37pm UTC](https://it.discourse.mcneel.com/t/analisi-del-codice/4935/60 "2023-02-20T16:37:46Z")

</div>

> [@emilio](#):
>
> Quindi la cosa poco chiara e’ il fatto che la conversione in stringa restituisce il **Member name** anziche’ il **value**.

> [@emilio](#):
>
> Cioe’, e’ semplicemente una regola del linguaggio: se converti un valore **enum** in stringa, ottieni il nome.

mmmm ma forse Emilio intendevi l’inverso essendo che come me hai spiegato il funzionamento è inverso

> [@0904](#):
>
> sorry, qui ho invertito il risultato di **enum**  
> essendo che, il risultato è una stringa ma come mi facessi vedere, poi con int viene convertito in numero

**enum** ritorna **Member name** convertendo quest’ultimo con int riporta il valore numero ad esso associato

spero che questa cosa sia almeno così. . . ho provato anche in C# e funziona come appena descritto

> [@emilio](#):
>
> ```auto
> variabile tipo valore str() int()
> a | ObjectType | 4 | 'Curve' | 4
> 
> ```

il **valore 4** da te esposto lo ricavi convertendo il **risultato stringa** dell’enum ObjectType in questo caso

* * *

edit:  
quindi di default:  
print(ObjectType)  
output: **Member name**

convertendolo in int  
print((int)ObjectType)  
output: **Value**

forse l’ordine dovrebbe essere più questo:

```auto
variabile tipo default str() Convert.ToInt('Curve')
a | ObjectType | 'Curve' | 4

```

una cosa simile a quella sopra, ma poi magari mi correggi. . .

[Pagina precedente](https://it.discourse.mcneel.com/t/analisi-del-codice/4935.md?page=2)

[Pagina seguente](https://it.discourse.mcneel.com/t/analisi-del-codice/4935.md?page=4)