In its first five years of existence, The Perl Journal ran 247 articles by over 120 authors. Every serious Perl programmer subscribed to it, and every notable Perl guru jumped at the opportunity to write for it. TPJ explained critical topics such as regular expressions, databases, and object-oriented programming, and demonstrated Perl's utility for fields as diverse as astronomy, biology, economics, AI, and games. The magazine gave birth to both the Obfuscated Perl Contest and the Perl Poetry contest, and remains a proud and timeless achievement of Perl during one of its most exciting periods of development. Computer Science and Perl Programming is the first volume of The Best of the Perl Journal, compiled and re-edited by the original editor and publisher of The Perl Journal, Jon Orwant. In this series, we've taken the very best (and still relevant) articles published in TPJ over its 5 years of publication and immortalized them into three volumes. This volume has 70 articles devoted to hard-core computer science, advanced programming techniques, and the underlying mechanics of Perl. Here's a sample of what you'll find inside:

Jeffrey Friedl on Understanding Regexes
Mark Jason Dominus on optimizing your Perl programs with Memoization
Damian Conway on Parsing
Tim Meadowcroft on integrating Perl with Microsoft Office
Larry Wall on the culture of Perl

Written by 41 of the most prominent and prolific members of the closely-knit Perl community, this anthology does what no other book can, giving unique insight into the real-life applications and powerful techniques made possible by Perl. Other books tell you how to use Perl, but this book goes far beyond that: it shows you not only how to use Perl, but what you could use Perl *for*. This is more than just The Best of the Perl Journal -- in many ways, this is the best of Perl.

Contenuti

Foreword; Preface; Finding Perl Resources; Conventions Used in This Book; Comments and Questions; Acknowledgments; Chapter 1: Introduction; 1.1 History of TPJ; 1.2 Computer Science and Perl Programming; Beginner Concepts; Chapter 2: All About Arrays; 2.1 Basics; 2.2 Positions; 2.3 Position Versus Count; 2.4 Foreach Loops; 2.5 The Reverse and Sort Functions; 2.6 Slices; 2.7 Adding and Deleting Values; 2.8 Lists to Strings and Back Again; 2.9 Putting It All Together; Chapter 3: Perfect Programming; 3.1 Warnings with -w; 3.2 The strict Pragma; 3.3 Tainting and Safe; 3.4 Checking Return Values; 3.5 Planning for Failure; 3.6 The Perl Debugger; 3.7 The Perl Profiler; 3.8 Stack Traces; Chapter 4: Precedence; 4.1 What Is Precedence?; 4.2 Rules and More Rules; 4.3 An Explosion of Rules; 4.4 Precedence Traps and Surprises; 4.5 List Operators and Unary Operators; 4.6 Complete Rules of Precedence; 4.7 How to Remember All the Rules; 4.8 Quiz; 4.9 Answers; Chapter 5: The Birth of a One-Liner; Chapter 6: Comparators, Sorting, and Hashes; 6.1 Sorting; 6.2 Sorting Hashes; 6.3 Efficient Sorting; 6.4 Further Reading; Chapter 7: What Is Truth?; 7.1 The undef Function; 7.2 Back to Truth; 7.3 Truth in Context; 7.4 Applications; 7.5 Conclusion; Chapter 8: Using Object-Oriented Modules; 8.1 Modules and Their Functional Interfaces; 8.2 Modules with Object-Oriented Interfaces; 8.3 What Can You Do with Objects?; 8.4 What’s in an Object?; 8.5 What Is an Object Value?; 8.6 So Why Do Some Modules Use Objects?; Chapter 9: Unreal Numbers; 9.1 A Surprising Program; 9.2 The Right Way; Chapter 10: CryptoContext; 10.1 Context; 10.2 Prototypes; 10.3 Subroutine Calls; 10.4 Putting Them All Together; 10.5 Conclusion; Chapter 11: References; 11.1 Who Needs Complicated Data Structures?; 11.2 The Solution; 11.3 Making References; 11.4 Using References; 11.5 An Example; 11.6 Solution; 11.7 The Rest; 11.8 In Summary; Chapter 12: Perl Heresies; 12.1 Don’t Use -w; 12.2 Don’t Use Regular Expressions Just Because They’re Cool; 12.3 Don’t Always Use Modules; 12.4 Partial Solutions Are Okay; Regular Expressions; Chapter 13: Understanding Regular Expressions, Part I; 13.1 The Story of Fred; 13.2 Reality Check; 13.3 Regular Expression Background; 13.4 Perl Regex Engine Basics; 13.5 The First Real Rule of Regexes; 13.6 A Single Match Attempt; 13.7 Options, Options, Options; 13.8 How the Path Is Chosen; 13.9 That’s Pretty Much It; Chapter 14: Understanding Regular Expressions, Part II; 14.1 Knowing Versus Knowing on Paper; 14.2 Efficiency; 14.3 Benchmarking; 14.4 Conclusion; Chapter 15: Understanding Regular Expressions, Part III; Chapter 16: Nibbling Strings; 16.1 The Problem; 16.2 Going on a Diet; Chapter 17: How Regexes Work; 17.1 Machines; 17.2 Blank Arrows; 17.3 Rules Again; 17.4 How to Turn a Regex into a Penny Machine; 17.5 What Do You Mean, Done?; 17.6 The Regex Module; 17.7 Implications for Perl; 17.8 What About Backreferences?; 17.9 Internals of Regex.pm; 17.10 Lies; 17.11 Other Directions; 17.12 Bibliography; Computer Science; Chapter 18: Infinite Lists; 18.1 Hamming’s Problem; 18.2 Streams; 18.3 Hamming’s Problem Revisited; 18.4 Dataflow Programming; 18.5 Other Directions; 18.6 References; Chapter 19: Compression; 19.1 Morse Code; 19.2 Ambiguous Codes; 19.3 Huffman Coding; 19.4 The Code; 19.5 The Rub; 19.6 Another Rub; 19.7 Other Methods; 19.8 Other Directions; 19.9 Bibliography; Chapter 20: Memoization; 20.1 Recursive Functions; 20.2 The Memoize Module; 20.3 Module Internals; 20.4 Some Other Applications of Memoization; 20.5 When Memoizing Doesn’t Work; 20.6 Bibliography; Chapter 21: Parsing; 21.1 A Sample Parse; 21.2 Formal Grammars; 21.3 The Different Types of Parsers; 21.4 Building a Parser with Parse::RecDescent; 21.5 How Parse::RecDescent Works; 21.6 An In-Depth Example; 21.7 Advanced Features of Parse::RecDescent; 21.8 Practical Applications of Parsing; 21.9 Limitations of Parse::Recdescent; 21.10 More Information; 21.11 Acknowledgments; Chapter 22: Trees and Game Trees; 22.1 What Is a Tree?; 22.2 Formal Definition; 22.3 Markup Language Trees; 22.4 Building Your Own Trees; 22.5 An Implementation: Game Trees for Alak; 22.6 References; Chapter 23: B_Trees; 23.1 A Review of Binary Trees; 23.2 The Problem with Binary Trees; 23.3 B-Trees Are Always Balanced; 23.4 A Guided Tour of the Program; 23.5 Moving Down; 23.6 Moving Up; 23.7 Details; 23.8 Other Directions; 23.9 Bibliography; Chapter 24: Making Life and Death Decisions with Perl; 24.1 Probability Theory; 24.2 Whoa!; 24.3 Perl; 24.4 Last Words; Chapter 25: Information Retrieval; 25.1 Text Searches on Manual Pages; 25.2 The Implementation; 25.3 Relevance Feedback; 25.4 “Advanced” Search Operators; 25.5 Conclusion; 25.6 References; Chapter 26: Randomness; 26.1 Congruential Generators; 26.2 Choosing the Seed; 26.3 LFSRs; 26.4 References; Chapter 27: Random Number Generators and XS; 27.1 Random Versus Pseudorandom Numbers; 27.2 Linear Congruential Generators Revisited; 27.3 A Better Generator for Perl; 27.4 Bridging C and Perl with XS; 27.5 Acknowledgments; 27.6 References; Programming Techniques; Chapter 28: Suffering from Buffering; 28.1 What Is Buffering?; 28.2 Surprise!; 28.3 Disabling Inappropriate Buffering; 28.4 Hot and Not Hot; 28.5 Other Perils of Buffering; 28.6 Flushing on Command; 28.7 Other Directions; 28.8 Summary; Chapter 29: Scoping; 29.1 Package Variables; 29.2 The Current Package; 29.3 Package Variable Trivia; 29.4 Lexical Variables; 29.5 local and my; 29.6 What Good Is local?; 29.7 When to Use my and When to Use local; 29.8 Other Properties of my Variables; 29.9 my Variable Trivia; 29.10 Declarations; 29.11 Summary; Chapter 30: Seven Useful Uses of local; 30.1 1. Special Variables; 30.2 2. Localized Filehandles; 30.3 3. The First Class Filehandle Trick; 30.4 4. Aliases; 30.5 5. Dynamic Scope; 30.6 6. Dynamic Scope Revisited; 30.7 7. Perl 4 and Other Relics; 30.8 Summary; Chapter 31: Parsing Command-Line Options; 31.1 Option Parsing Conventions; 31.2 The Simplest Way; 31.3 The Easy Way; 31.4 The Advanced Way; 31.5 Other Option Handling Modules; Chapter 32: Building a Better Hash with tie; 32.1 Introduction; 32.2 The Problem; 32.3 Discussion; 32.4 Attempted Solutions; 32.5 A Working Data Structure; 32.6 Implementation; 32.7 Implementing a Tied Hash; 32.8 Using a Tied Hash; 32.9 Testing; 32.10 Optimizations; 32.11 Making It a Module; 32.12 Summing Up; 32.13 References; Chapter 33: Source Filters; 33.1 Concepts; 33.2 Using Filters; 33.3 Writing a Source Filter; 33.4 The Debug Filter; 33.5 Conclusion; Chapter 34: Overloading; 34.1 Defining Your Own Types; 34.2 Adding Methods to the Date Class; 34.3 A Minor Problem; 34.4 Introducing Overloading; 34.5 Overloading More Methods; 34.6 Overloading and Associativity; 34.7 Full Overloading Implementations; 34.8 Automatically Generating Overloaded Methods; 34.9 The Fallback Mechanism; 34.10 Overloading and Inheritance; 34.11 Limitations of Operator Overloading; 34.12 Conclusion; 34.13 References; Chapter 35: Building Objects Out of Arrays; 35.1 OO Basics; 35.2 Arrays Are Faster; 35.3 Arrays Use Less Space; 35.4 Arrays Can Prevent Attribute Collisions; 35.5 Arrays Can Prevent Misspellings; 35.6 Disadvantages; 35.7 Other Approaches; Chapter 36: Hiding Objects with Closures; 36.1 A Simple Example; 36.2 Closures; 36.3 What About Inheritance?; 36.4 Conclusion; Chapter 37: Multiple Dispatch in Perl; 37.1 Multiple Dispatch; 37.2 Multiple Dispatch via “Tests-in-Methods”; 37.3 Multiple Dispatch via a Table; 37.4 Comparing the Two Approaches; 37.5 Dynamic Dispatch Tables; 37.6 The Class::Multimethods Module; Software Development; Chapter 38: Using Other Languages from Perl; 38.1 Introducing Inline.pm; 38.2 A More Complex Example; 38.3 Calling C Functions from Perl; 38.4 Manipulating Perl’s Stack; 38.5 How Inline Works; 38.6 Creating Perl Extensions; 38.7 Inline::Config; 38.8 XS and SWIG; 38.9 Using Perl as C’s Memory Manager; 38.10 Benchmarks; Chapter 39: SWIG; 39.1 Hooks by Hand; 39.2 Wrapping a C Function; 39.3 Interface Files; 39.4 An In-Depth Example: Emulating top; 39.5 The top Emulator; 39.6 Conclusion; Chapter 40: Benchmarking; 40.1 The Trouble with time( ); 40.2 Better Resolution with times; 40.3 The Benchmark Module; 40.4 Example: Summing an Array; 40.5 Conclusion; Chapter 41: Building Software with Cons; 41.1 Make Doesn’t Do the Right Thing; 41.2 The Solution: Cons; 41.3 Summary; Chapter 42: MakeMaker; 42.1 Reasons to Use MakeMaker; 42.2 h2xs; 42.3 Components of Makefile.PL; 42.4 A Deeper Example; 42.5 Advanced Makefile Features; 42.6 MakeMaker and Installation of Modules; 42.7 perllocal.pod; Chapter 43: Autoloading Perl Code; 43.1 Why Autoload?; 43.2 Using the AutoLoader; 43.3 How Autoloading Works; 43.4 AutoSplitting Your Module; 43.5 AutoLoading Scripts; 43.6 AutoLoading C Programs; 43.7 Summary; Chapter 44: Debugging and Devel::; 44.1 Runtime Examination of Data; 44.2 Profiling and Coverage Testing; 44.3 Reference Manipulation; 44.4 Helping C and C++ Programmers; 44.5 Rolling Your Own; 44.6 Which Should You Use?; Networking; Chapter 45: Email with Attachments; 45.1 What Is MIME, and Why Do I Care?; 45.2 How Does MIME Encode Data?; 45.3 Multiple Pieces of MIME; 45.4 How to Create a Mime Message; 45.5 An Alternate Route; 45.6 A Full-Blown Example; 45.7 Conclusion; Chapter 46: Sending Mail Without sendmail; 46.1 Some Email Background; 46.2 The Mail Itself; 46.3 Sending Mail in Six Easy Steps; 46.4 What Next?; Chapter 47: Filtering Mail; 47.1 What Is It?; 47.2 A Very Simple Mail Filter; 47.3 Separating Mail into Folders; 47.4 Mail and News; 47.5 A Complete Filter; 47.6 Caveats; 47.7 Conclusion; Chapter 48: Net::Telnet; 48.1 The Problem; 48.2 The Solution; 48.3 Telnetting the Hard Way; 48.4 Telnetting the Easy Way; 48.5 Telnetting the Easiest Way; 48.6 Special Considerations; 48.7 Other Features; Chapter 49: Microsoft Office; 49.1 Background; 49.2 The Problem; 49.3 The Solution; 49.4 Wait, There’s More; Chapter 50: Client-Server Applications; 50.1 Using the inetd Super-Daemon; 50.2 A Standalone Server; 50.3 A Threaded Server; 50.4 Launching Standalone Servers from inetd; 50.5 Further Information; Chapter 51: Managing Streaming Audio; 51.1 Playlists, Streams, and ID3 Tags; 51.2 Apache::MP3; 51.3 Conclusion; Chapter 52: A 74-Line Ip Telephone; 52.1 Sound Cards and /dev/dsp; 52.2 The Simple Version; 52.3 Adding an MP3 Encoder; 52.4 Summary; 52.5 References; Chapter 53: Controlling Modems; 53.1 Initializing Your Modem; 53.2 Getting Your Modem to Dial; 53.3 To Block or Not to Block?; 53.4 What’s Next?; 53.5 Afterword; 53.6 References; Chapter 54: Using Usenet from Perl; 54.1 Finding Newsgroups; 54.2 Retrieving Articles; 54.3 Posting Articles; Chapter 55: Transferring Files with FTP; 55.1 A Simple Example; 55.2 Multiple FTP Connections; 55.3 Transferring Files Between Servers; Chapter 56: Spidering an FTP Site; 56.1 Motivation; 56.2 Net::FTP; 56.3 Downloading a File (the Simple Case); 56.4 Recursion; 56.5 Downloading a File Tree (the Recursive Case); 56.6 Uploading a File (the Simple Case); 56.7 Uploading a File Tree (the Recursive Case); 56.8 Applications; Chapter 57: DNS Updates with Perl; 57.1 DNS Basics; 57.2 DNS Servers; 57.3 Dynamic Update; 57.4 Setting Up Your Nameserver; 57.5 Delegating the Zone; 57.6 Using Net::DNS::Update; 57.7 Paths for Futher Exploration; Databases; Chapter 58: DBI; 58.1 The Architecture of DBI; 58.2 Why DBI?; 58.3 The Modules; 58.4 Handles; 58.5 Resources; 58.6 Sample Code; Chapter 59: Using DBI with Microsoft Access; 59.1 The Win32-Access-ODBC-DBI::DBD Checklist:; 59.2 References; Chapter 60: DBI Caveats; 60.1 DBI and Loops; 60.2 Placeholders; 60.3 Fetches; 60.4 Bind Columns; 60.5 Error Checking; 60.6 Transactions; 60.7 References; Chapter 61: Beyond Hardcoded Database Applications with DBIx::Recordset; 61.1 CRUD Without SQL; 61.2 Sample Usage; 61.3 A DBI Version; 61.4 Conclusion; Chapter 62: Win32::ODBC; 62.1 Win32::ODBC Basics; 62.2 Demystifying SQL; 62.3 Installing Win32::ODBC; 62.4 Getting Started; 62.5 Debugging; 62.6 CRUD; 62.7 Transactions; 62.8 Data Sources; 62.9 Data Dictionary; 62.10 Conclusion; Chapter 63: Net::LDAP; 63.1 What Is LDAP?; 63.2 Setting Up an OpenLDAP Server; 63.3 Loading Data into the Directory; 63.4 A Searchable Web Interface to Manage Your Directory; 63.5 Where LDAP Is Going; 63.6 References; Chapter 64: Web Databases the Genome Project Way; 64.1 The ACEDB Database; 64.2 ACEDB Objects and Classes; 64.3 Accessing ACEDB from Perl; 64.4 ACEDB Meets the Web; 64.5 Registering ACEDB Displays; 64.6 Conclusions; 64.7 References; Chapter 65: Spreadsheet::WriteExcel; 65.1 Using Spreadsheet::WriteExcel; 65.2 How the Spreadsheet::WriteExcel Module Works; 65.3 Alternative Ways of Writing to Excel; 65.4 Reading from Excel; 65.5 Win32::OLE; 65.6 Obtaining Spreadsheet::WriteExcel; 65.7 References; Internals; Chapter 66: How to Improve Perl; Chapter 67: Components of the Perl Distribution; 67.1 The Components of Perl; 67.2 Summary; Chapter 68: Basic Perl Anatomy; 68.1 How Perl Works; 68.2 Lexical Analysis; 68.3 Parsing; 68.4 Compilation; 68.5 Execution; 68.6 Perl Subsystems; 68.7 For Further Reading; Chapter 69: Lexical Analysis; 69.1 Tokenizing; 69.2 Perl’s Lexer; 69.3 Lexer Variables; 69.4 Tokenizing Considerations; 69.5 Further Information; Chapter 70: Debugging Perl Programs with -D; 70.1 What -D Does for You; 70.2 Trace Execution with -Dt; 70.3 Stack Snapshots with -Ds; 70.4 Syntax Tree Dump with -Dx; 70.5 Regular Expression Parsing and Execution with -Dr; 70.6 Method and Overloading Resolution with -Do; 70.7 Context (Loop) Stack Processing with -Dl; 70.8 Tokenizing and Parsing with -Dp; 70.9 Other -D Debugging Flags; Chapter 71: Microperl; 71.1 Bootstrapping; 71.2 Building Microperl; 71.3 How Microperl Works; 71.4 Practical Uses for Microperl; 71.5 Problems; 71.6 Future Work; Colophon;

Le informazioni nella sezione "Su questo libro" possono far riferimento a edizioni diverse di questo titolo.

Descrizione libreria

The Saint Bookstore has a range of over 1 million titles available.

Visita la pagina della libreria

Informazioni sull?azienda del venditore

SB ONLINE LTD
50 Devonshire Road, Southport, PR9 7BZ, United Kingdom

Condizioni di vendita e spedizione

Condizioni di vendita

Please order through the Abebooks checkout. We only take orders through Abebooks - We don't take direct orders by email or phone.

Refunds or Returns: A full refund of the purchase price will be given if returned within 30 days in undamaged condition.

As a seller on abebooks we adhere to the terms explained at http://www.abebooks.co.uk/docs/HelpCentral/buyerIndex.shtml - if you require further assistance please email us at orders@thesaintbookstore.co.uk

Diritto di recesso

Se sei un consumatore, puoi esercitare il tuo diritto di recesso seguendo le istruzioni riportate di seguito. Per "consumatore" si intende qualsiasi persona fisica che agisca per fini che non rientrano nel quadro della sua attivit� commerciale, industriale, artigianale o professionale.

Informazioni relative al diritto di recesso

Diritto di recesso

Hai il diritto di recedere dal presente contratto, senza indicarne le ragioni, entro 14 giorni.

Il periodo di recesso scade dopo 14 giorni dal giorno in cui

tu acquisisci, o un terzo designato diverso dal vettore e da te acquisisce, il possesso fisico dell'ultimo bene o l'ultimo lotto o pezzo.

Per esercitare il diritto di recesso, sei tenuto a informare THE SAINT BOOKSTORE, 50 Devonshire Road, PR9 7BZ, Southport, United Kingdom, 44 17042241479, della tua decisione di recedere dal presente contratto tramite una dichiarazione esplicita (ad esempio lettera inviata per posta, fax o posta elettronica). A tal fine puoi utilizzare il modulo tipo di recesso, ma non e' obbligatorio. Puoi anche compilare e inviare elettronicamente il modulo tipo di recesso o qualsiasi altra esplicita dichiarazione sul nostro sito web, dalla sezione "Ordini" nel "Mio Account". Nel caso scegliessi questa opzione, ti trasmetteremo senza indugio una conferma di ricevimento su un supporto durevole (ad esempio per posta elettronica).

Per rispettare il termine di recesso, � sufficiente inviare la comunicazione relativa all'esercizio del diritto di recesso prima della scadenza del periodo di recesso.

Effetti del recesso

Se recedi dal presente contratto, ti saranno rimborsati tutti i pagamenti che hai effettuato a nostro favore, compresi i costi di consegna (ad eccezione dei costi supplementari derivanti dalla tua eventuale scelta di un tipo di consegna diverso dal tipo meno costoso di consegna standard da noi offerto). Potremo trattenere dal rimborso le somme derivanti da una diminuzione del valore del prodotto risultante da una tua non necessaria manipolazione.

I rimborsi verranno effettuati senza indebito ritardo e in ogni caso non oltre 14 giorni dal giorno in cui siamo stati informati della tua decisione di recedere dal presente contratto.

Detti rimborsi saranno effettuati utilizzando lo stesso mezzo di pagamento da te usato per la transazione iniziale, salvo che tu non abbia espressamente convenuto altrimenti; in ogni caso, non dovrai sostenere alcun costo quale conseguenza di tale rimborso. Il rimborso pu� essere sospeso fino al ricevimento dei beni oppure fino all'avvenuta dimostrazione da parte tua di aver rispedito i beni, se precedente.

Ti preghiamo di rispedire i beni o di consegnarli a THE SAINT BOOKSTORE, 50 Devonshire Road, PR9 7BZ, Southport, United Kingdom, 44 17042241479, senza indebiti ritardi e in ogni caso entro 14 giorni dal giorno in cui hai comunicato il tuo recesso dal presente contratto. Il termine � rispettato se rispedisci i beni prima della scadenza del periodo di 14 giorni. I costi diretti della restituzione dei beni saranno a tuo carico. Sei responsabile solo della diminuzione del valore dei beni risultante da una manipolazione del bene diversa da quella necessaria per stabilire la natura, le caratteristiche e il funzionamento dei beni.

Eccezioni al diritto di recesso

Il diritto di recesso non si applica in caso di:

fornitura di giornali, periodici e riviste ad eccezione dei contratti di abbonamento per la fornitura di tali pubblicazioni;
fornitura di contenuto digitale (inclusi applicazioni, software, ebook, MP3, ecc.) mediante un supporto non materiale (per esempio un CD o un DVD) se al momento dell'inoltro dell'ordine hai espressamente consentito all'inizio dell'esecuzione accettando la perdita del diritto di recesso in conseguenza dell'inizio di esecuzione.

Modulo di recesso tipo

(Compilare e restituire il presente modulo solo se si desidera recedere dal contratto)

Destinatario: (THE SAINT BOOKSTORE, 50 Devonshire Road, PR9 7BZ, Southport, United Kingdom, 44 17042241479)

Con la presente io/noi (*) notifichiamo il recesso dal mio/nostro (*) contratto di vendita dei seguenti beni/servizi (*)

Ordinato il (*) /ricevuto il (*)

Nome del/dei consumatore(i)

Indirizzo del/dei consumatore(i)

Firma del/dei consumatore(i) (solo se il presente modulo � notificato in versione cartacea)

Data

(*) Cancellare la dicitura inutile.

Condizioni di spedizione

Most orders usually ship within 1-3 business days, but some can take up to 7 days.

Tariffe di spedizione da Regno Unito a U.S.A.

Tariffe di spedizione da Regno Unito a U.S.A.
Quantit� dell?ordine	Da 7 a 28 giorni lavorativi	Da 7 a 28 giorni lavorativi
Primo articolo	EUR 27.14	EUR 29.45

I tempi di consegna sono stabiliti dai venditori e variano in base al corriere e al paese. Gli ordini che devono attraversare una dogana possono subire ritardi e spetta agli acquirenti pagare eventuali tariffe o dazi associati. I venditori possono contattarti in merito ad addebiti aggiuntivi dovuti a eventuali maggiorazioni dei costi di spedizione dei tuoi articoli.