Quando devono tipi deboli essere scoraggiati?

StackOverflow https://stackoverflow.com/questions/597664

  •  11-09-2019
  •  | 
  •  

Domanda

Quando dovrebbero tipi deboli essere scoraggiati? Sono tipi deboli scoraggiato in grandi progetti? Se il lato sinistro è fortemente tipizzato come la seguente vorrei che essere un'eccezione alla regola? 

   int i = 5
   string sz = i
   sz = sz + "1"
   i  = sz

C'è qualche supporto dei linguaggi di sintassi simile al precedente? Dimmi di più su vantaggi e svantaggi per i tipi deboli e situazioni legate.

È stato utile?

Soluzione

Penso che si sta confondendo "tipizzazione debole" con "la tipizzazione dinamica".

Il termine "tipizzazione debole" significa "non tipizzata", che significa che il valore di una locazione di memoria viene lasciata variare rispetto a quanto è tipo indica che dovrebbe essere.

C è un esempio di un linguaggio debolmente tipizzato. Esso consente il codice come questo da scrivere: 

typedef struct
{
    int x;
    int y;

} FooBar;

FooBar foo;
char * pStr = &foo;
pStr[0] = 'H';
pStr[1] = 'i';
pStr[2] = '\0';

Cioè, permette un'istanza FooBar di essere trattata come se fosse un array di caratteri.

In un linguaggio fortemente tipizzato, che non sarebbe stato consentito. O un errore di compilazione sarebbe generato, o un'eccezione fase di esecuzione sarebbe stato gettato, ma mai, in qualsiasi momento, sarebbe un indirizzo di memoria FooBar contenere dati che non era un FooBar valido.

C #, Java, Lisp, Java Script, e Ruby sono esempi di lingue in cui questo tipo di cose non sarebbe stato permesso. Essi sono fortemente tipizzati.

Alcune di queste lingue sono "staticamente tipizzati", il che significa che i tipi di variabili sono assegnate in fase di compilazione, e alcuni sono "dinamicamente tipizzati", il che significa che i tipi di variabili non sono noti fino al runtime. "Static vs dinamica" e "debole vs forte" sono questioni ortogonali. Ad esempio, Lisp è un "forte dinamicamente tipizzati" linguaggio, mentre "C" è un "debole linguaggio a tipizzazione statica".

Inoltre, come altri hanno fatto notare, c'è una distinzione tra "tipi dedurre" e tipi specificati dal programmatore. La parola chiave "var" in C # è un esempio di inferenza di tipo. Tuttavia, è ancora un costrutto staticamente tipizzato perché il compilatore deduce il tipo di una variabile al momento della compilazione, piuttosto che in fase di esecuzione.

Quindi, ciò che la tua domanda in realtà sta chiedendo è:

  

Quali sono i meriti e   inconvenienti di tipizzazione statica, dinamica   battitura, digitando debole, digitando stong,   tipi statici dedotti e utente   tipi statici specificati.

I fornire risposte a tutti questi qui sotto:

tipizzazione statica

tipizzazione statica ha 3 vantaggi principali:

  1. Miglior supporto utensili
  2. Una cappa probabile ridotto di taluni tipi di bug
  3. Prestazioni

L'esperienza utente e la precisione di cose come Intellisence, e refactoring è migliorata notevolmente in un linguaggio a tipizzazione statica a causa delle informazioni supplementari che i tipi statici forniscono. Se si digita "a". in un editor di codice e "a" ha un tipo statico, allora il compilatore sa tutto ciò che poteva legalmente venire dopo il "" e può quindi vi mostrerà un elenco di completamento accurata. E 'possibile sostenere alcuni scenari in un linguaggio tipizzato in modo dinamico, ma sono molto più limitate.

Inoltre, in un programma senza errori di compilazione strumento refactoring può identificare ogni luogo viene utilizzato un particolare metodo, variabile, o tipo. Non è possibile farlo in un linguaggio tipizzato in modo dinamico.

Il secondo vantaggio è alquanto controversa. I fautori di linguaggi staticamente tipizzati piace fare tale affermazione. Gli oppositori di linguaggi staticamente tipizzati, tuttavia, sostengono che gli insetti che catturano sono banali, e che avrebbero farsi prendere testando in ogni modo. Ma, si vuole ricevere la notifica di cose come i nomi delle variabili o metodo errate su fronte, che può essere utile.

lingue staticamente tipizzati consentono anche meglio "analisi del flusso dei dati", che, combinato con le cose come Microsoft SAL (o strumenti analoghi) può aiutare a trovare potenziali problemi di sicurezza.

Infine, con tipizzazione statica, compilatori possono fare molto di più di ottimizzazione, e quindi in grado di produrre codice più veloce.

Svantaggi:

Lo svantaggio principale per la tipizzazione statica è che essa limita le cose che puoi fare. È possibile scrivere programmi in lingue dinamicamente tipizzati che non si può scrivere in lingue staticamente tipizzati. Ruby on Rails è un buon esempio di questo.

Dinamico Digitando

Il grande vantaggio di tipizzazione dinamica è che è molto più potente di tipizzazione statica. Si può fare un sacco di veramente coroba olo con esso.

Un altro è che richiede meno di battitura. Non è necessario specificare i tipi in tutto il luogo.

Svantaggi:

tipizzazione dinamica ha 2 principali spalle di disegnare:

  1. Non si ottiene tanto "mano che tiene" dal compilatore o IDE
  2. Non è adatto per gli scenari di prestazioni critiche. Per esempio, nessuno scrive OS Kernel in Ruby.

Forte tipizzazione:

Il più grande vantaggio della tipizzazione forte è la sicurezza. Far rispettare tipizzazione forte di solito richiede un certo tipo di supporto runtime. Se un programma può proove sicurezza di tipo poi un sacco di problemi di sicurezza, come ad esempio overuns tampone, solo andare via.

tipizzazione debole:

Il grosso inconveniente di tipizzazione forte, e il grande vantaggio di tipizzazione debole, è la prestazione.

Quando si può accedere alla memoria come più ti piace, è possibile scrivere codice più veloce. Ad esempio, un database può scambiare oggetti su disco solo scrivendo le loro byte prime, e non dover ricorrere a cose come interfacce "ISerializable". Un videogioco può buttare via tutti i dati associati a un livello da solo in esecuzione un solo libero su un buffer di grandi dimensioni, piuttosto che correre distruttori per molti piccoli oggetti.

Essere in grado di fare quelle cose richiede tipizzazione debole.

L'inferenza di tipo

L'inferenza di tipo permette un sacco di benefici della tipizzazione statica senza richiedere fino a digitare.

Tipi di utente specificato

Alcune persone semplicemente non piace l'inferenza di tipo perché a loro piace essere esplicito. Questo è più di una cosa stile.

Altri suggerimenti

tipizzazione debole è un tentativo di semplificare il linguaggio. Anche se questo è un obiettivo degno, tipizzazione debole è una soluzione povera.

tipizzazione debole, come viene utilizzato in COM Varianti fu un primo tentativo di risolvere questo problema, ma è pieno di pericoli e francamente provoca più problemi che ne vale la pena. Anche i programmatori Visual Basic, che metteranno con tutti i tipi di rifiuti, ancorato correttamente questo come una cattiva idea e backronymed ETC di Microsoft (tipo esteso Conversione) al Male Tipo Cast.

Non confondere la tipizzazione dedurre con tipizzazione debole. tipizzazione dedotta è forte tipizzazione dedotta dal contesto in fase di compilazione. Un buon esempio è la parola chiave var, utilizzata in C # per dichiarare una variabile adatto a ricevere il valore di un'espressione LINQ.

Per contro, tipizzazione debole viene dedotta ogni volta un'espressione viene valutata. Questo è illustrato nel codice di esempio del problema. Un altro esempio potrebbe essere l'uso di puntatori non tipizzato in C. Molto utile ancora chiedere l'elemosina di guai.

digitando derivato affronta lo stesso problema di tipizzazione debole, senza introducendo i problemi associati con tipizzazione debole. Si tratta quindi di un'alternativa preferita ogniqualvolta linguaggio ospite rende disponibile.

Essi devono quasi sempre essere scoraggiati. L'unico tipo di codice che mi viene in mente dove sarebbe richiesto è il codice di basso livello che richiede un certo puntatore voodoo.

E per rispondere alla tua domanda, C supporta il codice del genere (ad eccezione, naturalmente, per non avere un tipo stringa), e che suona come qualcosa di PHP o Perl dovrebbe (ma potrebbe essere del tutto sbagliato in questo).

"

  

Quando dovrebbero tipi deboli essere scoraggiati? Sono tipi deboli scoraggiato in   grandi progetti? Se il lato sinistro è fortemente tipizzato come la seguente   vorrei che essere un'eccezione alla regola?

     

int i = 5 string sz = i sz = sz + "1" i = sz

     

C'è qualche supporto dei linguaggi di sintassi simile al precedente? Dimmi di più   su pro e contro per i tipi deboli e situazioni legate.

"

Forse si potrebbe programmare la propria libreria di farlo.

In C ++ è possibile utilizzare qualcosa chiamato un "sovraccarico operator", il che significa che è possibile dichiarare una variabile di un tipo da inizializzare come variabile di un altro tipo. Questo è ciò che rende la dichiarazione: 

[std::string str = "Hello World";][1]

specificamente che si definisce una funzione (in cui il tipo di variabile è T e B è il tipo che si desidera impostare come)

lavoro, anche se qualsiasi testo tra virgolette viene interpretato come un array di caratteri. 

T& T::operator= ( const B s );

Si prega di notare che questa è la funzione membro di una classe Si noti inoltre che probabilmente si vuole avere un qualche tipo di funzione che inverte questa manipolazione, se si desidera utilizzarlo liberamente - qualcosa come 

B& T::operator= ( const T s);

C ++ è abbastanza potente da permettere di effettuare un oggetto in generale debolmente tipizzato, ma se si vuole trattare puramente debolmente tipizzato, si vuole fare un solo tipo di variabile che può essere utilizzato come qualsiasi primitiva, e utilizzare solo funzioni che accettano un puntatore a vuoto. Credetemi, è molto più facile da usare programmazione fortemente tipizzato quando è disponibile.

Io personalmente preferisco fortemente tipizzato, perché non ho bisogno di preoccuparsi per gli errori che vengono quando non so che cosa una variabile è destinata a fare. Ad esempio, se volessi scrivere una funzione per parlare con una persona - e che la funzione usato l'altezza della persona, il peso, il nome, il numero di figli, ecc - ma mi hai dato un colore, vorrei avere un errore perché si può 't realmente determinare la maggior parte di queste cose per un colore utilizzando un algoritmo che è molto semplice.

Per quanto riguarda i pro di debolmente tipizzato, si potrebbe desiderare di abituarsi a digitato liberamente la programmazione, se si sta programmando qualcosa per essere eseguito all'interno di un programma (cioè. Un browser Web o una shell UNIX). sono debolmente tipizzato Javascript e Shell Script.

Vorrei suggerire che un linguaggio di programmazione come il linguaggio assembly è uno dei pochi harware-level lingue debolmente tipizzato, ma il sapore del linguaggio Assembly ho visto attribuisce un tipo per ciascuna variabile a seconda delle dimensioni assegnato, vale a dire la parola, DWORD, QWORD.

Spero che vi ho dato una buona spiegazione e non ho messo alcuna parola in bocca.

tipi deboli sono per loro natura meno robusto tipi forti, perché non dite la macchina esattamente cosa fare - invece la macchina deve capire che cosa volevi dire. Questo spesso funziona abbastanza adeguato, ma in generale non è chiaro quale sia il risultato dovrebbe essere. Qual è, ad esempio, una stringa moltiplicato per galleggiante?

  

C'è qualche supporto dei linguaggi di sintassi simile al precedente?

Perl consente di trattare alcuni numeri e stringhe in modo intercambiabile. Ad esempio, "5" + "1" vi darà 6. Il problema di questo genere di cose, in generale, è che può essere difficile da evitare ambiguità: dovrebbe "5" + 1 essere "51" o "6"? Perl aggira questo avendo un operatore separato per concatenazione di stringhe, e riservando + per l'addizione numerico.

Altre lingue avrebbero dovuto risolvere se hai intenzione di fare una concatenazione o di un'aggiunta, e (se del caso) che tipo o di rappresentanza il risultato sarà.

Ho fatto codifica ASP / VBScript e lavorare con il codice legacy senza opzione "rigorosa", che consente la tipizzazione debole.

E 'stato un inferno in molte volte, soprattutto nelle mani dei programmatori meno esperti. Ci siamo tutti gli errori stupidi prende le età da diagnosticare.

Uno degli esempi stupidi era come questo: 

'Config 
    Dim pass
    pass = "asdasd"


If NOT pass = Request("p") Then
Response.Write "login failed"
REsponse.End()
End If

Fin qui tutto bene, ma se l'utente passa passano ad una password intero, indovinate un po 'che non funziona più perché int passare! = Passaggio stringa (da querystring). Ho pensato che dovrebbe funzionare ma non ha non riesco a ricordare il pezzo esatto di codice .

Odio tipizzazione debole, invece di sessione di debug stupido posso spendere secondi in più per la tipizzazione tipo esatto di una variabile.

In poche parole, nella mia esperienza in particolare nei grandi progetti e in particolare con gli sviluppatori inesperti è solo guai.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top