I have had the opportunity to design and develop a variety of concepts for multiple projects. I enjoy bringing ideas to life, and acquiring the new skills required to do so.
My affinity for web design started in college when I first encountered Adobe Creative Suite, particularly the Illustrator and Flash Components. Through my studies, I continued to broaden and improve my skills with Adobe Creative Suite while also furthering my experience with Sublime and Atom through on the job training while working at Dougherty Forestry Manufacturing and various freelance and contract web-design jobs.
I developed my earlier websites at the front end using css, html, flash, and javascript. My later websites required databases allowing me to learn PHP, MySQL, and AJAX.
I enjoy web-designing and furthering my coding skills. I’m unashamedly addicted to coffee, which coincidently may be linked to my lack of sleep. I find running and biking to be therapeutic. And, I’ve never met a food I wouldn’t try at least once!


JavaScript is disabled on your browser.
Skip navigation links
Package
Class
Use
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes
SEARCH:
JavaScript is disabled on your browser.
A
B
C
D
E
F
G
H
I
L
M
N
P
Q
R
S
T
U
V
W
Y
G
gamename
- Variable in class
mainpage
Label for the game's name
gameover
- Variable in class
PlayGame
A boolean variable which tells if game is over or not
gameover()
- Method in class
PlayGame
Displays GameOver screen when snake dies
GameOver
- Class in
<Unnamed>
GameOver()
- Constructor for class
GameOver
GameScore
- Variable in class
PlayGame
getAaa()
- Method in class
PlayGame
getAlive()
- Method in class
snake
getAnimation()
- Method in class
PlayGame
getBody()
- Method in class
snake
getBomb1()
- Method in class
PlayGame
getBottomLabel()
- Method in class
PlayGame
getBurst_arr()
- Method in class
Block
getBurst_arr()
- Method in class
snake
getC()
- Method in class
Head
getCoin1()
- Method in class
PlayGame
getCoin2()
- Method in class
PlayGame
getColour()
- Method in class
Block
getColour()
- Method in class
Special_Coin
getDisplayGameScore()
- Method in class
PlayGame
getDisplayPlayerScore()
- Method in class
PlayGame
getDistance()
- Method in class
Magnet
getDuration()
- Method in class
Magnet
getDuration()
- Method in class
Shield
getExec()
- Method in class
PlayGame
getExit()
- Method in class
mainpage
getForsheild()
- Method in class
PlayGame
getGamename()
- Method in class
mainpage
getGameScore()
- Method in class
PlayGame
getGscore()
- Method in class
PlayGame
getHd()
- Method in class
snake
getHead()
- Method in class
snake
getHighest_score()
- Method in class
Player
getHiss()
- Method in class
PlayGame
getHome()
- Method in class
mainpage
getHome()
- Method in class
PlayGame
getHtplay()
- Method in class
mainpage
getImg()
- Method in class
Special_Coin
getImg()
- Method in class
Token
getL()
- Method in class
Coin
getL()
- Method in class
Head
getL()
- Method in class
mainpage
getLeaderboard()
- Method in class
mainpage
getLen()
- Method in class
snake
getLen()
- Method in class
Wall
getMagnet1()
- Method in class
PlayGame
getMainmenu()
- Method in class
PlayGame
getMMButton()
- Method in class
PlayGame
getMpage()
- Method in class
PlayGame
getName()
- Method in class
Player
getNum()
- Method in class
Block
getNum_balls()
- Method in class
Head
getNum_coins()
- Method in class
Player
getNumBalls()
- Method in class
Head
getPauseButton()
- Method in class
PlayGame
getPlay()
- Method in class
mainpage
getPlayerList()
- Method in class
Leaderboard
getPlayerScore()
- Method in class
PlayGame
getPlaygame()
- Method in class
mainpage
getPos()
- Method in class
snake
getPscore()
- Method in class
PlayGame
getPython()
- Method in class
Token
getRadius()
- Method in class
Ball
getRect()
- Method in class
Block
getRect()
- Method in class
Wall
getRestartgame()
- Method in class
PlayGame
getRow1()
- Method in class
PlayGame
getScoin1()
- Method in class
PlayGame
getSheildtime()
- Method in class
PlayGame
getShield1()
- Method in class
PlayGame
getSize()
- Method in class
Block
getstatus()
- Method in class
Token
getTemp()
- Method in class
PlayGame
getTextfield()
- Method in class
mainpage
getTimerforshield()
- Method in class
PlayGame
getTopLabel()
- Method in class
PlayGame
getValue()
- Method in class
Block
getValue()
- Method in class
Coin
getValue()
- Method in class
PlayGame
getValue()
- Method in class
Special_Coin
getWall1()
- Method in class
PlayGame
getWindow()
- Method in class
mainpage
getWindow()
- Method in class
PlayGame
gscore
- Variable in class
PlayGame
A
B
C
D
E
F
G
H
I
L
M
N
P
Q
R
S
T
U
V
W
Y
Skip navigation links
Package
Class
Use
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes
JavaScript is disabled on your browser.


This campaign will end on<EMAIL_ADDRESS>Please visit the campaign to monitor the progress of this campaign: @CERTIFICATION.NAME@
Campaign Details:
- Campaign ID: @CERTIFICATION.ID@
- Campaign Name: @CERTIFICATION.NAME@
- Campaign Type: @CERTIFICATION.TYPE@
- Start date: @CERTIFICATION.STARTDATE@
- End date: @CERTIFICATION.ENDDATE@


Engagement heatmap
{{wfname}} {{reportSearch.fromdtdisplay}} - {{reportSearch.todtdisplay}}
{{totalinit}} Workflows
Cancelled workflows are not included
This workflow has changed during the report period, we only show the most up to date workflow.
Start phase
{{tableCell.engper}}%
{{tableCell.engper}}


Sensory Integration Dysfunction is part of the key symptoms associated with Autism, and ADHD. We are different neurobiologically, and due to the different wiring of our nervous systems and neural networks, we are susceptible to being overwhelmed by sensory inputs. The sensory channels include:
The enteric nervous system has been recently discovered: neurons are located within the digestive system, and this could possibility be the cause of many episodes of irritable bowel disorder associated with chronic anxiety, particularly for autistics. Anxiety can cause many immune system flare ups and problems with the digestive system, and the discovery of the enteric nervous system helps explain why we "feel" things in our stomach, like butterflies when we have anxiety and panic attacks.
Autistics and people with AD/HD are completely different with wiring and neurobiological structures. Imaging studies and autopsies on the brain of autistic people have shown clear delineations in the structures of both nervous systems and the brain of autistics and neurotypicals. Different areas of the brain are literally wired differently. It is often difficult to explain to neurotypical people that you, as either a person with AD/HD or Autism are markedly different and exhibit all of the issues associated with having sensory integration dysfunction, but the existence of this app can help you to explain to people why you need to take some time out to go and soothe your nervous system.
We recommend the use of headphones with The Serenity App. The Serenity App is made by Almond Digital Technologies, app developer Lori V Woodward. For privacy and more terms and conditions see Almond Digital Technologies or visit The Serenity App webpage.


On the ethics of having children
Oct 26, 2020 in Philosophy
Read PostOct 26, 2020 in Philosophy
Read PostJul 5, 2020 in Fiction
Read PostOct 12, 2019 in Fiction
Read PostOct 19, 2018 in Scam, Software, Technology
Read PostApr 2, 2018 in Random
Read PostJul 25, 2017 in Software, Technology
Read PostJul 4, 2017 in Travel
Read PostSep 20, 2016 in Freelancing, Web Development
Read PostJun 20, 2016 in Internships
Read Post


Ağıllı Dostum Privacy statement
Ağıllı Dostum does not collect or share any personal information.
It is an offline open source program developed for children and totally safe and free.
Our Contact<EMAIL_ADDRESS>Latest update: October 2, 2019


Invalidate sessions when users log out.
Invalidating sessions when users log out makes it harder to hijack them.
To invalidate sessions when users log out:
Identify logout functionality. Find code that is responsible for the logout functionality.
Add code to invalidate sessions. Add the following code to the logout function to invalidate the session:
session.Invalidate();
where "session" is an HttpSession object.


1. Enter your home address or account number.
2. A map and photo will show your water meter location. The meter is under the orange traffic cone.
The meter looks similar to this example:
If the meter is not found with this tool, contact the City of Surrey for help.


In this challenge, we were trying to use straws and tapes to make contraption to hold golf which dropped from six feet high. The contraption we made need to prevent golf ball from touching the ground. This seemed really easy at beginning since we were given 12 straws. However, we were acutally only allowed to let 3 straws touch the ground. We also needed to make sure that our contraption would hold the dropped golf ball stably. In my group, we bended and cutted straws to make a small basket. Then we sticked three half-cutted straw on the bottom of the basket to make sure that there were only three straws touched ground and at the same time the basket is stable. During the testing, our contraption almost held the golf ball successfully, but the contraption itself was stil not stable enough. As such we failed, but I still really enjoy the process of designing and making this small contraption with my classmates.
In this second challenge, we were trying to use newspaper to make a Skyscraper as high as possible. My group member and I made a really practical design. We used newspaper to make a cone shape as the bottom of the skyscraper. The cone shape newspaper just looks like a Christmas tree which is unbelievably stable. With this stable basis of our skycraper, we begined to build it up. We rolled the other newspaper to long and slim cylinders, connecting those cylinders by tapes and putting them on the vertext of the cone. Finally our group had the highest skyscraper in our class!


Internet Death Penalty
`Prev `__
I
`Next `__
--------------
**Internet Death Penalty**
[Usenet] (often abbreviated IDP) The ultimate sanction against
`*spam* <../S/spam.html>`__-emitting sites — complete shunning at the
router level of all mail and packets, as well as Usenet messages, from
the offending domain(s). Compare `*Usenet Death
Penalty* <../U/Usenet-Death-Penalty.html>`__, with which it is sometimes
confused.
--------------
+-----------------------------+----------------------------+--------------------------------------+
| `Prev `__ | `Up <../I.html>`__ | `Next `__ |
+-----------------------------+----------------------------+--------------------------------------+
| Internet | `Home <../index.html>`__ | Internet Exploder |
+-----------------------------+----------------------------+--------------------------------------+


Module OdbObject
Class "OdbObject".
Functions
| OdbObject:data () | object method. |
| OdbObject:free () | Destroy this object (will be called by Garbage Collector). |
| OdbObject:id () | object method. |
| OdbObject:size () | object method. |
| OdbObject:type () | object method. |
Functions
- OdbObject:data ()
-
object method.
Calls git_odb_object_data:
This is the uncompressed, raw data as read from the ODB, without the leading header.
This pointer is owned by the object and shall not be free'd.
Calls git_odb_object_size:
This is the real size of the `data` buffer, not the actual size of the object.
Return value:
string
. - OdbObject:free ()
-
Destroy this object (will be called by Garbage Collector).
Calls git_odb_object_free:
This method must always be called once a `git_odb_object` is no longer needed, otherwise memory will leak.
- OdbObject:id ()
-
object method.
Calls git_odb_object_id:
This is the OID from which the object was read from
Return value:
OID. - OdbObject:size ()
-
object method.
Calls git_odb_object_size:
This is the real size of the `data` buffer, not the actual size of the object.
Return value:
integer
. - OdbObject:type ()
-
object method.
Calls git_odb_object_type:
Return value:
string
.


OAReports for creating custom reports and print forms, with binding and templates that use OAModels.


Download spreadsheet using {{accessionType}} accession {{accession}}
Set {{accessionType}} accession(s) to download a pre-populated HCA metadata spreadsheet


Build your awesome project together
Hello, my name is John Doe, I am a new developer that code projects using HTML, CSS and Twitter Bootstrap. If you are interested by my skill, feel free to send me an email at<EMAIL_ADDRESS>Hello, my name is John Doe, I am a new developer that code projects using HTML, CSS and Twitter Bootstrap. If you are interested by my skill, feel free to send me an email at john.doe@acme.com


Examples of adding your key to this file: pgp -kxa <your name> and append it to this file. (pgpk -ll <your name> && pgpk -xa <your name>) >> this file. (gpg --list-sigs <your name> && gpg --armor --export <your name>) >> this file.
Elect a release manager.
Create a ticket for a new release in JIRA. If you do not have permission to do so just ask to be given permissions on the mailing list.
Review all of the JIRA issues associated with the release. All issues should be resolved and closed.
Any issues assigned to the release that are not complete should be assigned to the next release. Any critical or blocker issues should be resolved on the mailing list. Discuss any issues that you are unsure of on the mailing list.
The following steps need only to be performed once.
Make sure you have your PGP key entered into https://id.apache.org/. Your KEYS will then be present in https://people.apache.org/keys/group/opennlp.asc.
Make sure you have your PGP keys password.
Add your PGP key to the KEYS file:
Examples of adding your key to this file: pgp -kxa <your name> and append it to this file. (pgpk -ll <your name> && pgpk -xa <your name>) >> this file. (gpg --list-sigs <your name> && gpg --armor --export <your name>) >> this file.
In a local temp folder, svn checkout the OpenNLP artifacts and update the KEYS file
svn co https://dist.apache.org/repos/dist/release/opennlp/ svn commit -m"Added Key for <name>" KEYS
Create a maven settings.xml
to publish to repository.apache.org
. An example configuration:
<server> <id>apache.releases.https</id> <username>Your Apache Username</username> <password>Your Apache Password</password> </server>
Checkout the Apache OpenNLP master branch: git clone git@github.com:apache/opennlp.git
Execute a complete test (it can take several hours): mvn test -DOPENNLP_DATA_DIR=/path/to/opennlp-test-data/ -Peval-tests
Do a trial build: mvn package -Papache-release
Prepare the release: mvn release:prepare
Answer the questions appropriately. The tag name format should be opennlp-x.y.z.
This command creates and pushes two new commits to the repository to reflect the version changes. It also tags the release.
Perform the release: mvn release:perform
This creates a staged repository at http://repository.apache.org.
Check the staged repository and if all looks well, close the staging repository but do not promote or release it at this time.
The build results are in opennlp/target/checkout/target
. Do not modify or delete these files.
Perform basic checks against the release binary:
Check signature of generated artifacts.
Check presence and appropriateness of LICENSE
, NOTICE
, and README
files.
Notify the developer mailing list of a new version vote. Be sure to replace all values in []
with the appropriate values.
Message Subject: [VOTE] Apache OpenNLP [version] Release Candidate
Hi folks, I have posted a [Nth] release candidate for the Apache OpenNLP [version] release and it is ready for testing. The distributables can be downloaded from: https://repository.apache.org/content/repositories/orgapacheopennlp-[REPO_NUM]/org/apache/opennlp/opennlp-distr/[VERSION]/ The release was made from the Apache OpenNLP [VERSION] tag at: https://github.com/apache/opennlp/tree/opennlp-[VERSION] To use it in a maven build set the version for opennlp-tools or opennlp-uima to [VERSION] and add the following URL to your settings.xml file: https://repository.apache.org/content/repositories/orgapacheopennlp-[REPO_NUM] The release was made using the OpenNLP release process, documented on the website: https://opennlp.apache.org/release.html Please vote on releasing these packages as Apache OpenNLP [VERSION]. The vote is open for at least the next 72 hours. Only votes from OpenNLP PMC are binding, but everyone is welcome to check the release candidate and vote. The vote passes if at least three binding +1 votes are cast. [ ] +1 Release the packages as Apache OpenNLP [VERSION] [ ] -1 Do not release the packages because... Thanks!
The vote is successful if at least 3 +1 votes are received from OpenNLP PMC members after a minimum of 72 hours of sending the vote email. Acknowledge the voting results on the mailing list in the VOTE thread.
Release the staging repository. This will make the artifacts available in the Maven Central repository. To do this go to the repository server, log in, go to the staging area and release the staging repository linked to this release
Commit the distribution via SVN to https://dist.apache.org/repos/dist/release:
svn co https://dist.apache.org/repos/dist/release/opennlp/ dist # check if the KEYS file contains your key, if not, update it # copy opennlp/target/checkout/target/apache-opennlp* to dist/opennlp-<VERSION> svn commit --username <username> -m "Adding OpenNLP <version>"
To reduce the load on the ASF mirrors, projects are required to delete old releases (see http://www.apache.org/legal/release-policy.html#when-to-archive).
Remove the old releases from SVN under https://dist.apache.org/repos/dist/release/opennlp/.
Update the website once the new version appears in the Apache download mirrors (keep checking http://www.apache.org/dyn/closer.cgi/opennlp until you see something):
Update the jbake.properties
file to include the new version numbers:
opennlp.version=
opennlp.next.version=
Add a new artifactItem in the pom.xml for the new OpenNLP release. (This automatically pulls in the details and javadocs for the new version when the site is built.):
<artifactItem>
<groupId>org.apache.opennlp</groupId>
<artifactId>opennlp-distr</artifactId>
[version]${project.version}</version>
<overWrite>false</overWrite>
<type>zip</type>
<classifier>bin</classifier>
<outputDirectory>${project.build.directory}/distr/1.8.1</outputDirectory>
</artifactItem>
Move the last version’s links to the documentation to the Legacy Documentation (https://opennlp.apache.org/docs/legacy.html) page. Add the following lines at the beginning of docs/legacy.ad
:
### Apache OpenNLP ${previous.release} documentation * link:/docs/${previous.release}/manual/opennlp.html[Apache OpenNLP Manual] * link:/docs/${previous.release}/apidocs/opennlp-tools/index.html[Apache OpenNLP Tools Javadoc] * link:/docs/${previous.release}/apidocs/opennlp-uima/index.html[Apache OpenNLP UIMA Javadoc] * link:/docs/${previous.release}/apidocs/opennlp-brat-annotator/index.html[Apache OpenNLP BRAT Annotator Javadoc] * link:/docs/${previous.release}/apidocs/opennlp-morfologik-addon/index.html[Apache OpenNLP Morfologik Addon Javadoc]
Update the doap_opennlp.rdf
file to reflect the new version number and release date.
Add a news item in news/release-{xyz}.ad
by copying the content from OpenNLP project opennlp-distr/src/README
.
Commit the website changes.
Rebuild opennlp-site and redeploy the site (if Automatic Buildbot doesn’t kick in)
Test and review the website. Test that all download links are working. Test that the documentation is updated and can be viewed
Log the new version at https://reporter.apache.org/addrelease.html?opennlp.
Announce the new version on the OpenNLP Twitter.
Announce the new version on the Apache OpenNLP blog at https://blogs.apache.org/opennlp/.
Close the present release ticket in JIRA.
Send announcement email to<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>This needs to be done from your @apache.org email address or the email will bounce from the announce list. Gmail forwarding can help here and is a snap to set up (http://gmailblog.blogspot.com/2009/07/send-mail-from-another-address-without.html). It’s even easier then the instructions there as it will recognize your email address and default to Apache settings. It is important to include a description of what OpenNLP is as well as a link to the updated DOAP within the release announcement, this is so others know what OpenNLP is.
Title: [ANNOUNCE] OpenNLP <version> released TO<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>Message body:
The Apache OpenNLP team is pleased to announce the release of version <version> of Apache OpenNLP. The Apache OpenNLP library is a machine learning based toolkit for the processing of natural language text. It supports the most common NLP tasks, such as tokenization, sentence segmentation, part-of-speech tagging, named entity extraction, chunking, and parsing. The OpenNLP <version> binary and source distributions are available for download from our download page: https://opennlp.apache.org/download.html The OpenNLP library is distributed by Maven Central as well. See the Maven Dependency page for more details: http://opennlp.apache.org/maven-dependency.html Changes in this version: ** TODO UPDATE THIS >> - change 1 - change 2 << TODO UPDATE THIS ** For a complete list of fixed bugs and improvements please see the RELEASE_NOTES file included in the distribution. The Apache OpenNLP Team
The release vote may fail due to an issue discovered in the release candidate. If the vote fails the release should be canceled by:
Sending an email to<EMAIL_ADDRESS>on the VOTE thread notifying of the vote’s cancellation.
Dropping the staging repository at https://repository.apache.org/.
Renaming the opennlp-x.y.x
tag to opennlp-x.y.z-RC1
.
A new release candidate can now be prepared. When complete, a new VOTE thread can be started as described in the steps above.


DUNGEONS & DRAGONS A film review by Steve Rhodes Copyright 2000 Steve Rhodes RATING (0 TO ****): 1/2
Jeremy Irons (Academy Award-winner for REVERSAL OF FORTUNE), we didn't know you had it in you. When you go slumming, as you do in Courtney Solomon's DUNGEONS & DRAGONS, your acting is not just merely awful but a major league stinkeroo.
Assuming you're not destitute and it isn't your evil twin in the picture, the only possible explanation left is that your work in the movie is one big inside joke.  You must hope that any film this bad has to become a cult classic, and that, if it does, your part in it will eventually be seen as a huge spoof. Someday you can tell the movie magazines that you intentionally tried to see just how terrible you could be. Watching you is such an embarrassment that I hope your strategy proves correct. I refuse to assume that you acted this pathetically unless it was on purpose.
To be fair, the performance by Thora Birch (Academy Award nominee for AMERICAN BEAUTY) is not much better. Looking like a little girl playing dress up, she delivers her lines with such awkwardness that she would be rejected for a community theater production.
The minimal plot, set in medieval times, involves the control of dragons and the saving of the empire.
"Please help me!" asks a character with iridescent blue lipstick played by Bruce Payne. He appears to want to be put out of his misery. Where is the bubonic plague when you need it? I wanted them all to die and the sooner, the better.
DUNGEONS & DRAGONS runs a long 1:45. It is rated PG-13 for fantasy action violence and would be acceptable for kids around 11 and up.
My son Jeffrey, age 11, and some of his classmates who saw the film with him really liked it. They thought it started slow, but the maze and the fighting scenes were awesome and the special effects were cool. Their ratings were pretty high: **** (Jeffrey, Steven, Kyle and Sam), *** 1/2 (Alan), *** (Nick) and ** 1/2 (John).
Email<EMAIL_ADDRESS>Web: http://www.InternetReviews.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


View Highscores
Time: 0
Javascript Quiz
Click the button to start!
Start Quiz
Enter Name
SCORES!
Clear Scores
Play again


I have a background in arts administration and currently work at two arts nonprofits: Open Signal (formerly Portland Community Media) as volunteer/engagement coordinator and S1 as curator and facilitator. My focus is creating avenues of access for all to engage with creativity, particularly historically marginalized and underrepresented populations.
I am currently a student through the Epicodus Intro to Programming course. I chose to take this course to bolster my skills and find a job that will merge my programming skills and my arts administration background.
In my free time I also work as DJ, and am currently a resident at Club Culo and Club Tropicana. My sound can be described as diasporic club, bringing together the sounds of the global underground. My mixes can be found on my Soundcloud. I have also done freelance writing for the Ace Hotel and the Portland Mercury.


NAME
perlre - Perl regular expressions
DESCRIPTION
This page describes the syntax of regular expressions in Perl.
If you haven't used regular expressions before, a quick-start introduction is available in perlrequick, and a longer tutorial introduction is available in perlretut.
For reference on how regular expressions are used in matching
operations, plus various examples of the same, see discussions of
m//
, s///
, qr//
and ??
in "Regexp Quote-Like Operators" in perlop.
Matching operations can have various modifiers. Modifiers that relate to the interpretation of the regular expression inside are listed below. Modifiers that alter the way a regular expression is used by Perl are detailed in "Regexp Quote-Like Operators" in perlop and "Gory details of parsing quoted constructs" in perlop.
- i
Do case-insensitive pattern matching.
If
use locale
is in effect, the case map is taken from the current locale. See perllocale. - m
Treat string as multiple lines. That is, change "^" and "$" from matching the start or end of the string to matching the start or end of any line anywhere within the string.
- s
Treat string as single line. That is, change "." to match any character whatsoever, even a newline, which normally it would not match.
The
/s
and/m
modifiers both override the$*
setting. That is, no matter what$*
contains,/s
without/m
will force "^" to match only at the beginning of the string and "$" to match only at the end (or just before a newline at the end) of the string. Together, as /ms, they let the "." match any character whatsoever, while still allowing "^" and "$" to match, respectively, just after and just before newlines within the string. - x
Extend your pattern's legibility by permitting whitespace and comments.
These are usually written as "the /x
modifier", even though the delimiter
in question might not really be a slash. Any of these
modifiers may also be embedded within the regular expression itself using
the (?...)
construct. See below.
The /x
modifier itself needs a little more explanation. It tells
the regular expression parser to ignore whitespace that is neither
backslashed nor within a character class. You can use this to break up
your regular expression into (slightly) more readable parts. The #
character is also treated as a metacharacter introducing a comment,
just as in ordinary Perl code. This also means that if you want real
whitespace or #
characters in the pattern (outside a character
class, where they are unaffected by /x
), that you'll either have to
escape them or encode them using octal or hex escapes. Taken together,
these features go a long way towards making Perl's regular expressions
more readable. Note that you have to be careful not to include the
pattern delimiter in the comment--perl has no way of knowing you did
not intend to close the pattern early. See the C-comment deletion code
in perlop.
Regular Expressions
The patterns used in Perl pattern matching derive from supplied in the Version 8 regex routines. (The routines are derived (distantly) from Henry Spencer's freely redistributable reimplementation of the V8 routines.) See "Version 8 Regular Expressions" for details.
In particular the following metacharacters have their standard egrep-ish meanings:
\ Quote the next metacharacter ^ Match the beginning of the line . Match any character (except newline) $ Match the end of the line (or before newline at the end) | Alternation () Grouping [] Character class
By default, the "^" character is guaranteed to match only the
beginning of the string, the "$" character only the end (or before the
newline at the end), and Perl does certain optimizations with the
assumption that the string contains only one line. Embedded newlines
will not be matched by "^" or "$". You may, however, wish to treat a
string as a multi-line buffer, such that the "^" will match after any
newline within the string, and "$" will match before any newline. At the
cost of a little more overhead, you can do this by using the /m modifier
on the pattern match operator. (Older programs did this by setting $*
,
but this practice is now deprecated.)
To simplify multi-line substitutions, the "." character never matches a
newline unless you use the /s
modifier, which in effect tells Perl to pretend
the string is a single line--even if it isn't. The /s
modifier also
overrides the setting of $*
, in case you have some (badly behaved) older
code that sets it in another module.
The following standard quantifiers are recognized:
* Match 0 or more times + Match 1 or more times ? Match 1 or 0 times {n} Match exactly n times {n,} Match at least n times {n,m} Match at least n but not more than m times
(If a curly bracket occurs in any other context, it is treated
as a regular character. In particular, the lower bound
is not optional.) The "*" modifier is equivalent to {0,}
, the "+"
modifier to {1,}
, and the "?" modifier to {0,1}
. n and m are limited
to integral values less than a preset limit defined when perl is built.
This is usually 32766 on the most common platforms. The actual limit can
be seen in the error message generated by code such as this:
$_ **= $_ , / {$_} / for 2 .. 42;
By default, a quantified subpattern is "greedy", that is, it will match as many times as possible (given a particular starting location) while still allowing the rest of the pattern to match. If you want it to match the minimum number of times possible, follow the quantifier with a "?". Note that the meanings don't change, just the "greediness":
*? Match 0 or more times +? Match 1 or more times ?? Match 0 or 1 time {n}? Match exactly n times {n,}? Match at least n times {n,m}? Match at least n but not more than m times
Because patterns are processed as double quoted strings, the following also work:
\t tab (HT, TAB) \n newline (LF, NL) \r return (CR) \f form feed (FF) \a alarm (bell) (BEL) \e escape (think troff) (ESC) \033 octal char (think of a PDP-11) \x1B hex char \x{263a} wide hex char (Unicode SMILEY) \c[ control char \N{name} named char \l lowercase next char (think vi) \u uppercase next char (think vi) \L lowercase till \E (think vi) \U uppercase till \E (think vi) \E end case modification (think vi) \Q quote (disable) pattern metacharacters till \E
If use locale
is in effect, the case map used by \l
, \L
, \u
and \U
is taken from the current locale. See perllocale. For
documentation of \N{name}
, see charnames.
You cannot include a literal $
or @
within a \Q
sequence.
An unescaped $
or @
interpolates the corresponding variable,
while escaping will cause the literal string \$
to be matched.
You'll need to write something like m/\Quser\E\@\Qhost/
.
In addition, Perl defines the following:
\w Match a "word" character (alphanumeric plus "_") \W Match a non-"word" character \s Match a whitespace character \S Match a non-whitespace character \d Match a digit character \D Match a non-digit character \pP Match P, named property. Use \p{Prop} for longer names. \PP Match non-P \X Match eXtended Unicode "combining character sequence", equivalent to (?:\PM\pM*) \C Match a single C char (octet) even under Unicode. NOTE: breaks up characters into their UTF-8 bytes, so you may end up with malformed pieces of UTF-8. Unsupported in lookbehind.
A \w
matches a single alphanumeric character (an alphabetic
character, or a decimal digit) or _
, not a whole word. Use \w+
to match a string of Perl-identifier characters (which isn't the same
as matching an English word). If use locale
is in effect, the list
of alphabetic characters generated by \w
is taken from the current
locale. See perllocale. You may use \w
, \W
, \s
, \S
,
\d
, and \D
within character classes, but if you try to use them
as endpoints of a range, that's not a range, the "-" is understood
literally. If Unicode is in effect, \s
matches also "\x{85}",
"\x{2028}, and "\x{2029}", see perlunicode for more details about
\pP
, \PP
, and \X
, and perluniintro about Unicode in general.
You can define your own \p
and \P
properties, see perlunicode.
The POSIX character class syntax
[:class:]
is also available. The available classes and their backslash equivalents (if available) are as follows:
alpha alnum ascii blank [1] cntrl digit \d graph lower print punct space \s [2] upper word \w [3] xdigit
- [1]
A GNU extension equivalent to
[ \t]
, "all horizontal whitespace". - [2]
Not exactly equivalent to
\s
since the[[:space:]]
includes also the (very rare) "vertical tabulator", "\ck", chr(11). - [3]
A Perl extension, see above.
For example use [:upper:]
to match all the uppercase characters.
Note that the []
are part of the [::]
construct, not part of the
whole character class. For example:
[01[:alpha:]%]
matches zero, one, any alphabetic character, and the percentage sign.
The following equivalences to Unicode \p{} constructs and equivalent backslash character classes (if available), will hold:
[:...:] \p{...} backslash
alpha IsAlpha alnum IsAlnum ascii IsASCII blank IsSpace cntrl IsCntrl digit IsDigit \d graph IsGraph lower IsLower print IsPrint punct IsPunct space IsSpace IsSpacePerl \s upper IsUpper word IsWord xdigit IsXDigit
For example [:lower:]
and \p{IsLower}
are equivalent.
If the utf8
pragma is not used but the locale
pragma is, the
classes correlate with the usual isalpha(3) interface (except for
"word" and "blank").
The assumedly non-obviously named classes are:
- cntrl
Any control character. Usually characters that don't produce output as such but instead control the terminal somehow: for example newline and backspace are control characters. All characters with ord() less than 32 are most often classified as control characters (assuming ASCII, the ISO Latin character sets, and Unicode), as is the character with the ord() value of 127 (
DEL
). - graph
Any alphanumeric or punctuation (special) character.
- print
Any alphanumeric or punctuation (special) character or the space character.
- punct
Any punctuation (special) character.
- xdigit
Any hexadecimal digit. Though this may feel silly ([0-9A-Fa-f] would work just fine) it is included for completeness.
You can negate the [::] character classes by prefixing the class name with a '^'. This is a Perl extension. For example:
POSIX traditional Unicode
[:^digit:] \D \P{IsDigit} [:^space:] \S \P{IsSpace} [:^word:] \W \P{IsWord}
Perl respects the POSIX standard in that POSIX character classes are only supported within a character class. The POSIX character classes [.cc.] and [=cc=] are recognized but not supported and trying to use them will cause an error.
Perl defines the following zero-width assertions:
\b Match a word boundary \B Match a non-(word boundary) \A Match only at beginning of string \Z Match only at end of string, or before newline at the end \z Match only at end of string \G Match only at pos() (e.g. at the end-of-match position of prior m//g)
A word boundary (\b
) is a spot between two characters
that has a \w
on one side of it and a \W
on the other side
of it (in either order), counting the imaginary characters off the
beginning and end of the string as matching a \W
. (Within
character classes \b
represents backspace rather than a word
boundary, just as it normally does in any double-quoted string.)
The \A
and \Z
are just like "^" and "$", except that they
won't match multiple times when the /m
modifier is used, while
"^" and "$" will match at every internal line boundary. To match
the actual end of the string and not ignore an optional trailing
newline, use \z
.
The \G
assertion can be used to chain global matches (using
m//g
), as described in "Regexp Quote-Like Operators" in perlop.
It is also useful when writing lex
-like scanners, when you have
several patterns that you want to match against consequent substrings
of your string, see the previous reference. The actual location
where \G
will match can also be influenced by using pos()
as
an lvalue: see pos. Currently \G
is only fully
supported when anchored to the start of the pattern; while it
is permitted to use it elsewhere, as in /(?<=\G..)./g
, some
such uses (/.\G/g
, for example) currently cause problems, and
it is recommended that you avoid such usage for now.
The bracketing construct ( ... )
creates capture buffers. To
refer to the digit'th buffer use \<digit> within the
match. Outside the match use "$" instead of "\". (The
\<digit> notation works in certain circumstances outside
the match. See the warning below about \1 vs $1 for details.)
Referring back to another part of the match is called a
backreference.
There is no limit to the number of captured substrings that you may use. However Perl also uses \10, \11, etc. as aliases for \010, \011, etc. (Recall that 0 means octal, so \011 is the character at number 9 in your coded character set; which would be the 10th character, a horizontal tab under ASCII.) Perl resolves this ambiguity by interpreting \10 as a backreference only if at least 10 left parentheses have opened before it. Likewise \11 is a backreference only if at least 11 left parentheses have opened before it. And so on. \1 through \9 are always interpreted as backreferences.
Examples:
s/^([^ ]*) *([^ ]*)/$2 $1/; # swap first two words
if (/(.)\1/) { # find first doubled char print "'$1' is the first doubled character\n"; }
if (/Time: (..):(..):(..)/) { # parse out values $hours = $1; $minutes = $2; $seconds = $3; }
Several special variables also refer back to portions of the previous
match. $+
returns whatever the last bracket match matched.
$&
returns the entire matched string. (At one point $0
did
also, but now it returns the name of the program.) $`
returns
everything before the matched string. $'
returns everything
after the matched string. And $^N
contains whatever was matched by
the most-recently closed group (submatch). $^N
can be used in
extended patterns (see below), for example to assign a submatch to a
variable.
The numbered match variables ($1, $2, $3, etc.) and the related punctuation
set ($+
, $&
, $`
, $'
, and $^N
) are all dynamically scoped
until the end of the enclosing block or until the next successful
match, whichever comes first. (See "Compound Statements" in perlsyn.)
NOTE: failed matches in Perl do not reset the match variables, which makes it easier to write code that tests for a series of more specific cases and remembers the best match.
WARNING: Once Perl sees that you need one of $&
, $`
, or
$'
anywhere in the program, it has to provide them for every
pattern match. This may substantially slow your program. Perl
uses the same mechanism to produce $1, $2, etc, so you also pay a
price for each pattern that contains capturing parentheses. (To
avoid this cost while retaining the grouping behaviour, use the
extended regular expression (?: ... )
instead.) But if you never
use $&
, $`
or $'
, then patterns without capturing
parentheses will not be penalized. So avoid $&
, $'
, and $`
if you can, but if you can't (and some algorithms really appreciate
them), once you've used them once, use them at will, because you've
already paid the price. As of 5.005, $&
is not so costly as the
other two.
Backslashed metacharacters in Perl are alphanumeric, such as \b
,
\w
, \n
. Unlike some other regular expression languages, there
are no backslashed symbols that aren't alphanumeric. So anything
that looks like \\, \(, \), \<, \>, \{, or \} is always
interpreted as a literal character, not a metacharacter. This was
once used in a common idiom to disable or quote the special meanings
of regular expression metacharacters in a string that you want to
use for a pattern. Simply quote all non-"word" characters:
$pattern =~ s/(\W)/\\$1/g;
(If use locale
is set, then this depends on the current locale.)
Today it is more common to use the quotemeta() function or the \Q
metaquoting escape sequence to disable all metacharacters' special
meanings like this:
/$unquoted\Q$quoted\E$unquoted/
Beware that if you put literal backslashes (those not inside
interpolated variables) between \Q
and \E
, double-quotish
backslash interpolation may lead to confusing results. If you
need to use literal backslashes within \Q...\E
,
consult "Gory details of parsing quoted constructs" in perlop.
Extended Patterns
Perl also defines a consistent extension syntax for features not found in standard tools like awk and lex. The syntax is a pair of parentheses with a question mark as the first thing within the parentheses. The character after the question mark indicates the extension.
The stability of these extensions varies widely. Some have been part of the core language for many years. Others are experimental and may change without warning or be completely removed. Check the documentation on an individual feature to verify its current status.
A question mark was chosen for this and for the minimal-matching construct because 1) question marks are rare in older regular expressions, and 2) whenever you see one, you should stop and "question" exactly what is going on. That's psychology...
(?#text)
A comment. The text is ignored. If the
/x
modifier enables whitespace formatting, a simple#
will suffice. Note that Perl closes the comment as soon as it sees a)
, so there is no way to put a literal)
in the comment.(?imsx-imsx)
One or more embedded pattern-match modifiers, to be turned on (or turned off, if preceded by
-
) for the remainder of the pattern or the remainder of the enclosing pattern group (if any). This is particularly useful for dynamic patterns, such as those read in from a configuration file, read in as an argument, are specified in a table somewhere, etc. Consider the case that some of which want to be case sensitive and some do not. The case insensitive ones need to include merely(?i)
at the front of the pattern. For example:$pattern = "foobar"; if ( /$pattern/i ) { }
# more flexible:
$pattern = "(?i)foobar"; if ( /$pattern/ ) { }
These modifiers are restored at the end of the enclosing group. For example,
( (?i) blah ) \s+ \1
will match a repeated (including the case!) word
blah
in any case, assumingx
modifier, and noi
modifier outside this group.(?:pattern)
(?imsx-imsx:pattern)
This is for clustering, not capturing; it groups subexpressions like "()", but doesn't make backreferences as "()" does. So
@fields = split(/\b(?:a|b|c)\b/)
is like
@fields = split(/\b(a|b|c)\b/)
but doesn't spit out extra fields. It's also cheaper not to capture characters if you don't need to.
Any letters between
?
and:
act as flags modifiers as with(?imsx-imsx)
. For example,/(?s-i:more.*than).*million/i
is equivalent to the more verbose
/(?:(?s-i)more.*than).*million/i
(?=pattern)
A zero-width positive look-ahead assertion. For example,
/\w+(?=\t)/
matches a word followed by a tab, without including the tab in$&
.(?!pattern)
A zero-width negative look-ahead assertion. For example
/foo(?!bar)/
matches any occurrence of "foo" that isn't followed by "bar". Note however that look-ahead and look-behind are NOT the same thing. You cannot use this for look-behind.If you are looking for a "bar" that isn't preceded by a "foo",
/(?!foo)bar/
will not do what you want. That's because the(?!foo)
is just saying that the next thing cannot be "foo"--and it's not, it's a "bar", so "foobar" will match. You would have to do something like/(?!foo)...bar/
for that. We say "like" because there's the case of your "bar" not having three characters before it. You could cover that this way:/(?:(?!foo)...|^.{0,2})bar/
. Sometimes it's still easier just to say:if (/bar/ && $` !~ /foo$/)
For look-behind see below.
(?<=pattern)
A zero-width positive look-behind assertion. For example,
/(?<=\t)\w+/
matches a word that follows a tab, without including the tab in$&
. Works only for fixed-width look-behind.(?<!pattern)
A zero-width negative look-behind assertion. For example
/(?<!bar)foo/
matches any occurrence of "foo" that does not follow "bar". Works only for fixed-width look-behind.(?{ code })
WARNING: This extended regular expression feature is considered highly experimental, and may be changed or deleted without notice.
This zero-width assertion evaluates any embedded Perl code. It always succeeds, and its
code
is not interpolated. Currently, the rules to determine where thecode
ends are somewhat convoluted.This feature can be used together with the special variable
$^N
to capture the results of submatches in variables without having to keep track of the number of nested parentheses. For example:$_ = "The brown fox jumps over the lazy dog"; /the (\S+)(?{ $color = $^N }) (\S+)(?{ $animal = $^N })/i; print "color = $color, animal = $animal\n";
Inside the
(?{...})
block,$_
refers to the string the regular expression is matching against. You can also usepos()
to know what is the current position of matching within this string.The
code
is properly scoped in the following sense: If the assertion is backtracked (compare "Backtracking"), all changes introduced afterlocal
ization are undone, so that$_ = 'a' x 8; m< (?{ $cnt = 0 }) # Initialize $cnt. ( a (?{ local $cnt = $cnt + 1; # Update $cnt, backtracking-safe. }) )* aaaa (?{ $res = $cnt }) # On success copy to non-localized # location. >x;
will set
$res = 4
. Note that after the match, $cnt returns to the globally introduced value, because the scopes that restrictlocal
operators are unwound.This assertion may be used as a
(?(condition)yes-pattern|no-pattern)
switch. If not used in this way, the result of evaluation ofcode
is put into the special variable$^R
. This happens immediately, so$^R
can be used from other(?{ code })
assertions inside the same regular expression.The assignment to
$^R
above is properly localized, so the old value of$^R
is restored if the assertion is backtracked; compare "Backtracking".For reasons of security, this construct is forbidden if the regular expression involves run-time interpolation of variables, unless the perilous
use re 'eval'
pragma has been used (see re), or the variables contain results ofqr//
operator (see "qr/STRING/imosx" in perlop).This restriction is because of the wide-spread and remarkably convenient custom of using run-time determined strings as patterns. For example:
$re = <>; chomp $re; $string =~ /$re/;
Before Perl knew how to execute interpolated code within a pattern, this operation was completely safe from a security point of view, although it could raise an exception from an illegal pattern. If you turn on the
use re 'eval'
, though, it is no longer secure, so you should only do so if you are also using taint checking. Better yet, use the carefully constrained evaluation within a Safe compartment. See perlsec for details about both these mechanisms.(??{ code })
WARNING: This extended regular expression feature is considered highly experimental, and may be changed or deleted without notice. A simplified version of the syntax may be introduced for commonly used idioms.
This is a "postponed" regular subexpression. The
code
is evaluated at run time, at the moment this subexpression may match. The result of evaluation is considered as a regular expression and matched as if it were inserted instead of this construct.The
code
is not interpolated. As before, the rules to determine where thecode
ends are currently somewhat convoluted.The following pattern matches a parenthesized group:
$re = qr{ \( (?: (?> [^()]+ ) # Non-parens without backtracking | (??{ $re }) # Group with matching parens )* \) }x;
(?>pattern)
WARNING: This extended regular expression feature is considered highly experimental, and may be changed or deleted without notice.
An "independent" subexpression, one which matches the substring that a standalone
pattern
would match if anchored at the given position, and it matches nothing other than this substring. This construct is useful for optimizations of what would otherwise be "eternal" matches, because it will not backtrack (see "Backtracking"). It may also be useful in places where the "grab all you can, and do not give anything back" semantic is desirable.For example:
^(?>a*)ab
will never match, since(?>a*)
(anchored at the beginning of string, as above) will match all charactersa
at the beginning of string, leaving noa
forab
to match. In contrast,a*ab
will match the same asa+b
, since the match of the subgroupa*
is influenced by the following groupab
(see "Backtracking"). In particular,a*
insidea*ab
will match fewer characters than a standalonea*
, since this makes the tail match.An effect similar to
(?>pattern)
may be achieved by writing(?=(pattern))\1
. This matches the same substring as a standalonea+
, and the following\1
eats the matched string; it therefore makes a zero-length assertion into an analogue of(?>...)
. (The difference between these two constructs is that the second one uses a capturing group, thus shifting ordinals of backreferences in the rest of a regular expression.)Consider this pattern:
m{ \( ( [^()]+ # x+ | \( [^()]* \) )+ \) }x
That will efficiently match a nonempty group with matching parentheses two levels deep or less. However, if there is no such group, it will take virtually forever on a long string. That's because there are so many different ways to split a long string into several substrings. This is what
(.+)+
is doing, and(.+)+
is similar to a subpattern of the above pattern. Consider how the pattern above detects no-match on((()aaaaaaaaaaaaaaaaaa
in several seconds, but that each extra letter doubles this time. This exponential performance will make it appear that your program has hung. However, a tiny change to this patternm{ \( ( (?> [^()]+ ) # change x+ above to (?> x+ ) | \( [^()]* \) )+ \) }x
which uses
(?>...)
matches exactly when the one above does (verifying this yourself would be a productive exercise), but finishes in a fourth the time when used on a similar string with 1000000a
s. Be aware, however, that this pattern currently triggers a warning message under theuse warnings
pragma or -w switch saying it"matches null string many times in regex"
.On simple groups, such as the pattern
(?> [^()]+ )
, a comparable effect may be achieved by negative look-ahead, as in[^()]+ (?! [^()] )
. This was only 4 times slower on a string with 1000000a
s.The "grab all you can, and do not give anything back" semantic is desirable in many situations where on the first sight a simple
()*
looks like the correct solution. Suppose we parse text with comments being delimited by#
followed by some optional (horizontal) whitespace. Contrary to its appearance,#[ \t]*
is not the correct subexpression to match the comment delimiter, because it may "give up" some whitespace if the remainder of the pattern can be made to match that way. The correct answer is either one of these:(?>#[ \t]*) #[ \t]*(?![ \t])
For example, to grab non-empty comments into $1, one should use either one of these:
/ (?> \# [ \t]* ) ( .+ ) /x; / \# [ \t]* ( [^ \t] .* ) /x;
Which one you pick depends on which of these expressions better reflects the above specification of comments.
(?(condition)yes-pattern|no-pattern)
(?(condition)yes-pattern)
WARNING: This extended regular expression feature is considered highly experimental, and may be changed or deleted without notice.
Conditional expression.
(condition)
should be either an integer in parentheses (which is valid if the corresponding pair of parentheses matched), or look-ahead/look-behind/evaluate zero-width assertion.For example:
m{ ( \( )? [^()]+ (?(1) \) ) }x
matches a chunk of non-parentheses, possibly included in parentheses themselves.
Backtracking
NOTE: This section presents an abstract approximation of regular expression behavior. For a more rigorous (and complicated) view of the rules involved in selecting a match among possible alternatives, see "Combining pieces together".
A fundamental feature of regular expression matching involves the
notion called backtracking, which is currently used (when needed)
by all regular expression quantifiers, namely *
, *?
, +
,
+?
, {n,m}
, and {n,m}?
. Backtracking is often optimized
internally, but the general principle outlined here is valid.
For a regular expression to match, the entire regular expression must match, not just part of it. So if the beginning of a pattern containing a quantifier succeeds in a way that causes later parts in the pattern to fail, the matching engine backs up and recalculates the beginning part--that's why it's called backtracking.
Here is an example of backtracking: Let's say you want to find the word following "foo" in the string "Food is on the foo table.":
$_ = "Food is on the foo table."; if ( /\b(foo)\s+(\w+)/i ) { print "$2 follows $1.\n"; }
When the match runs, the first part of the regular expression (\b(foo)
)
finds a possible match right at the beginning of the string, and loads up
$1 with "Foo". However, as soon as the matching engine sees that there's
no whitespace following the "Foo" that it had saved in $1, it realizes its
mistake and starts over again one character after where it had the
tentative match. This time it goes all the way until the next occurrence
of "foo". The complete regular expression matches this time, and you get
the expected output of "table follows foo."
Sometimes minimal matching can help a lot. Imagine you'd like to match everything between "foo" and "bar". Initially, you write something like this:
$_ = "The food is under the bar in the barn."; if ( /foo(.*)bar/ ) { print "got <$1>\n"; }
Which perhaps unexpectedly yields:
got <d is under the bar in the >
That's because .*
was greedy, so you get everything between the
first "foo" and the last "bar". Here it's more effective
to use minimal matching to make sure you get the text between a "foo"
and the first "bar" thereafter.
if ( /foo(.*?)bar/ ) { print "got <$1>\n" } got <d is under the >
Here's another example: let's say you'd like to match a number at the end of a string, and you also want to keep the preceding part of the match. So you write this:
$_ = "I have 2 numbers: 53147"; if ( /(.*)(\d*)/ ) { # Wrong! print "Beginning is <$1>, number is <$2>.\n"; }
That won't work at all, because .*
was greedy and gobbled up the
whole string. As \d*
can match on an empty string the complete
regular expression matched successfully.
Beginning is <I have 2 numbers: 53147>, number is <>.
Here are some variants, most of which don't work:
$_ = "I have 2 numbers: 53147"; @pats = qw{ (.*)(\d*) (.*)(\d+) (.*?)(\d*) (.*?)(\d+) (.*)(\d+)$ (.*?)(\d+)$ (.*)\b(\d+)$ (.*\D)(\d+)$ };
for $pat (@pats) { printf "%-12s ", $pat; if ( /$pat/ ) { print "<$1> <$2>\n"; } else { print "FAIL\n"; } }
That will print out:
(.*)(\d*) <I have 2 numbers: 53147> <> (.*)(\d+) <I have 2 numbers: 5314> <7> (.*?)(\d*) <> <> (.*?)(\d+) <I have > <2> (.*)(\d+)$ <I have 2 numbers: 5314> <7> (.*?)(\d+)$ <I have 2 numbers: > <53147> (.*)\b(\d+)$ <I have 2 numbers: > <53147> (.*\D)(\d+)$ <I have 2 numbers: > <53147>
As you see, this can be a bit tricky. It's important to realize that a regular expression is merely a set of assertions that gives a definition of success. There may be 0, 1, or several different ways that the definition might succeed against a particular string. And if there are multiple ways it might succeed, you need to understand backtracking to know which variety of success you will achieve.
When using look-ahead assertions and negations, this can all get even trickier. Imagine you'd like to find a sequence of non-digits not followed by "123". You might try to write that as
$_ = "ABC123"; if ( /^\D*(?!123)/ ) { # Wrong! print "Yup, no 123 in $_\n"; }
But that isn't going to match; at least, not the way you're hoping. It claims that there is no 123 in the string. Here's a clearer picture of why that pattern matches, contrary to popular expectations:
$x = 'ABC123'; $y = 'ABC445';
print "1: got $1\n" if $x =~ /^(ABC)(?!123)/; print "2: got $1\n" if $y =~ /^(ABC)(?!123)/;
print "3: got $1\n" if $x =~ /^(\D*)(?!123)/; print "4: got $1\n" if $y =~ /^(\D*)(?!123)/;
This prints
2: got ABC 3: got AB 4: got ABC
You might have expected test 3 to fail because it seems to a more
general purpose version of test 1. The important difference between
them is that test 3 contains a quantifier (\D*
) and so can use
backtracking, whereas test 1 will not. What's happening is
that you've asked "Is it true that at the start of $x, following 0 or more
non-digits, you have something that's not 123?" If the pattern matcher had
let \D*
expand to "ABC", this would have caused the whole pattern to
fail.
The search engine will initially match \D*
with "ABC". Then it will
try to match (?!123
with "123", which fails. But because
a quantifier (\D*
) has been used in the regular expression, the
search engine can backtrack and retry the match differently
in the hope of matching the complete regular expression.
The pattern really, really wants to succeed, so it uses the
standard pattern back-off-and-retry and lets \D*
expand to just "AB" this
time. Now there's indeed something following "AB" that is not
"123". It's "C123", which suffices.
We can deal with this by using both an assertion and a negation. We'll say that the first part in $1 must be followed both by a digit and by something that's not "123". Remember that the look-aheads are zero-width expressions--they only look, but don't consume any of the string in their match. So rewriting this way produces what you'd expect; that is, case 5 will fail, but case 6 succeeds:
print "5: got $1\n" if $x =~ /^(\D*)(?=\d)(?!123)/; print "6: got $1\n" if $y =~ /^(\D*)(?=\d)(?!123)/;
6: got ABC
In other words, the two zero-width assertions next to each other work as though
they're ANDed together, just as you'd use any built-in assertions: /^$/
matches only if you're at the beginning of the line AND the end of the
line simultaneously. The deeper underlying truth is that juxtaposition in
regular expressions always means AND, except when you write an explicit OR
using the vertical bar. /ab/
means match "a" AND (then) match "b",
although the attempted matches are made at different positions because "a"
is not a zero-width assertion, but a one-width assertion.
WARNING: particularly complicated regular expressions can take exponential time to solve because of the immense number of possible ways they can use backtracking to try match. For example, without internal optimizations done by the regular expression engine, this will take a painfully long time to run:
'aaaaaaaaaaaa' =~ /((a{0,5}){0,5})*[c]/
And if you used *
's in the internal groups instead of limiting them
to 0 through 5 matches, then it would take forever--or until you ran
out of stack space. Moreover, these internal optimizations are not
always applicable. For example, if you put {0,5}
instead of *
on the external group, no current optimization is applicable, and the
match takes a long time to finish.
A powerful tool for optimizing such beasts is what is known as an
"independent group",
which does not backtrack (see "look-behind assertions will not backtrack to make the tail match, since they are in "logical" context: only whether they match is considered relevant. For an example where side-effects of look-ahead might have influenced the following match, see "code>" in (?>pattern)>>>.<
" in (?>pattern)>>>). Note also that zero-length look-ahead
Version 8 Regular Expressions
In case you're not familiar with the "regular" Version 8 regex routines, here are the pattern-matching rules not described above.
Any single character matches itself, unless it is a metacharacter
with a special meaning described here or above. You can cause
characters that normally function as metacharacters to be interpreted
literally by prefixing them with a "\" (e.g., "\." matches a ".", not any
character; "\\" matches a "\"). A series of characters matches that
series of characters in the target string, so the pattern blurfl
would match "blurfl" in the target string.
You can specify a character class, by enclosing a list of characters
in []
, which will match any one character from the list. If the
first character after the "[" is "^", the class matches any character not
in the list. Within a list, the "-" character specifies a
range, so that a-z
represents all characters between "a" and "z",
inclusive. If you want either "-" or "]" itself to be a member of a
class, put it at the start of the list (possibly after a "^"), or
escape it with a backslash. "-" is also taken literally when it is
at the end of the list, just before the closing "]". (The
following all specify the same class of three characters: [-az]
,
[az-]
, and [a\-z]
. All are different from [a-z]
, which
specifies a class containing twenty-six characters, even on EBCDIC
based coded character sets.) Also, if you try to use the character
classes \w
, \W
, \s
, \S
, \d
, or \D
as endpoints of
a range, that's not a range, the "-" is understood literally.
Note also that the whole range idea is rather unportable between character sets--and even within character sets they may cause results you probably didn't expect. A sound principle is to use only ranges that begin from and end at either alphabets of equal case ([a-e], [A-E]), or digits ([0-9]). Anything else is unsafe. If in doubt, spell out the character sets in full.
Characters may be specified using a metacharacter syntax much like that
used in C: "\n" matches a newline, "\t" a tab, "\r" a carriage return,
"\f" a form feed, etc. More generally, \nnn, where nnn is a string
of octal digits, matches the character whose coded character set value
is nnn. Similarly, \xnn, where nn are hexadecimal digits,
matches the character whose numeric value is nn. The expression \cx
matches the character control-x. Finally, the "." metacharacter
matches any character except "\n" (unless you use /s
).
You can specify a series of alternatives for a pattern using "|" to
separate them, so that fee|fie|foe
will match any of "fee", "fie",
or "foe" in the target string (as would f(e|i|o)e
). The
first alternative includes everything from the last pattern delimiter
("(", "[", or the beginning of the pattern) up to the first "|", and
the last alternative contains everything from the last "|" to the next
pattern delimiter. That's why it's common practice to include
alternatives in parentheses: to minimize confusion about where they
start and end.
Alternatives are tried from left to right, so the first
alternative found for which the entire expression matches, is the one that
is chosen. This means that alternatives are not necessarily greedy. For
example: when matching foo|foot
against "barefoot", only the "foo"
part will match, as that is the first alternative tried, and it successfully
matches the target string. (This might not seem important, but it is
important when you are capturing matched text using parentheses.)
Also remember that "|" is interpreted as a literal within square brackets,
so if you write [fee|fie|foe]
you're really only matching [feio|]
.
Within a pattern, you may designate subpatterns for later reference
by enclosing them in parentheses, and you may refer back to the
nth subpattern later in the pattern using the metacharacter
\n. Subpatterns are numbered based on the left to right order
of their opening parenthesis. A backreference matches whatever
actually matched the subpattern in the string being examined, not
the rules for that subpattern. Therefore, (0|0x)\d*\s\1\d*
will
match "0x1234 0x4321", but not "0x1234 01234", because subpattern
1 matched "0x", even though the rule 0|0x
could potentially match
the leading 0 in the second number.
Warning on \1 vs $1
Some people get too used to writing things like:
$pattern =~ s/(\W)/\\\1/g;
This is grandfathered for the RHS of a substitute to avoid shocking the
sed addicts, but it's a dirty habit to get into. That's because in
PerlThink, the righthand side of an s///
is a double-quoted string. \1
in
the usual double-quoted string means a control-A. The customary Unix
meaning of \1
is kludged in for s///
. However, if you get into the habit
of doing that, you get yourself into trouble if you then add an /e
modifier.
s/(\d+)/ \1 + 1 /eg; # causes warning under -w
Or if you try to do
s/(\d+)/\1000/;
You can't disambiguate that by saying \{1}000
, whereas you can fix it with
${1}000
. The operation of interpolation should not be confused
with the operation of matching a backreference. Certainly they mean two
different things on the left side of the s///
.
Repeated patterns matching zero-length substring
WARNING: Difficult material (and prose) ahead. This section needs a rewrite.
Regular expressions provide a terse and powerful programming language. As with most other power tools, power comes together with the ability to wreak havoc.
A common abuse of this power stems from the ability to make infinite loops using regular expressions, with something as innocuous as:
'foo' =~ m{ ( o? )* }x;
The o?
can match at the beginning of 'foo'
, and since the position
in the string is not moved by the match, o?
would match again and again
because of the *
modifier. Another common way to create a similar cycle
is with the looping modifier //g
:
@matches = ( 'foo' =~ m{ o? }xg );
or
print "match: <$&>\n" while 'foo' =~ m{ o? }xg;
or the loop implied by split().
However, long experience has shown that many programming tasks may be significantly simplified by using repeated subexpressions that may match zero-length substrings. Here's a simple example being:
@chars = split //, $string; # // is not magic in split ($whitewashed = $string) =~ s/()/ /g; # parens avoid magic s// /
Thus Perl allows such constructs, by forcefully breaking
the infinite loop. The rules for this are different for lower-level
loops given by the greedy modifiers *+{}
, and for higher-level
ones like the /g
modifier or split() operator.
The lower-level loops are interrupted (that is, the loop is broken) when Perl detects that a repeated expression matched a zero-length substring. Thus
m{ (?: NON_ZERO_LENGTH | ZERO_LENGTH )* }x;
is made equivalent to
m{ (?: NON_ZERO_LENGTH )* | (?: ZERO_LENGTH )? }x;
The higher level-loops preserve an additional state between iterations: whether the last match was zero-length. To break the loop, the following match after a zero-length match is prohibited to have a length of zero. This prohibition interacts with backtracking (see "Backtracking"), and so the second best match is chosen if the best match is of zero length.
For example:
$_ = 'bar'; s/\w??/<$&>/g;
results in <><b><><a><><r><>
. At each position of the string the best
match given by non-greedy ??
is the zero-length match, and the second
best match is what is matched by \w
. Thus zero-length matches
alternate with one-character-long matches.
Similarly, for repeated m/()/g
the second-best match is the match at the
position one notch further in the string.
The additional state of being matched with zero-length is associated with
the matched string, and is reset by each assignment to pos().
Zero-length matches at the end of the previous match are ignored
during split
.
Combining pieces together
Each of the elementary pieces of regular expressions which were described
before (such as ab
or \Z
) could match at most one substring
at the given position of the input string. However, in a typical regular
expression these elementary pieces are combined into more complicated
patterns using combining operators ST
, S|T
, S*
etc
(in these examples S
and T
are regular subexpressions).
Such combinations can include alternatives, leading to a problem of choice:
if we match a regular expression a|ab
against "abc"
, will it match
substring "a"
or "ab"
? One way to describe which substring is
actually matched is the concept of backtracking (see "Backtracking").
However, this description is too low-level and makes you think
in terms of a particular implementation.
Another description starts with notions of "better"/"worse". All the substrings which may be matched by the given regular expression can be sorted from the "best" match to the "worst" match, and it is the "best" match which is chosen. This substitutes the question of "what is chosen?" by the question of "which matches are better, and which are worse?".
Again, for elementary pieces there is no such question, since at most
one match at a given position is possible. This section describes the
notion of better/worse for combining operators. In the description
below S
and T
are regular subexpressions.
ST
Consider two possible matches,
AB
andA'B'
,A
andA'
are substrings which can be matched byS
,B
andB'
are substrings which can be matched byT
.If
A
is better match forS
thanA'
,AB
is a better match thanA'B'
.If
A
andA'
coincide:AB
is a better match thanAB'
ifB
is better match forT
thanB'
.S|T
When
S
can match, it is a better match than when onlyT
can match.Ordering of two matches for
S
is the same as forS
. Similar for two matches forT
.S{REPEAT_COUNT}
Matches as
SSS...S
(repeated as many times as necessary).S{min,max}
Matches as
S{max}|S{max-1}|...|S{min+1}|S{min}
.S{min,max}?
Matches as
S{min}|S{min+1}|...|S{max-1}|S{max}
.S?
,S*
,S+
Same as
S{0,1}
,S{0,BIG_NUMBER}
,S{1,BIG_NUMBER}
respectively.S??
,S*?
,S+?
Same as
S{0,1}?
,S{0,BIG_NUMBER}?
,S{1,BIG_NUMBER}?
respectively.(?>S)
Matches the best match for
S
and only that.(?=S)
,(?<=S)
Only the best match for
S
is considered. (This is important only ifS
has capturing parentheses, and backreferences are used somewhere else in the whole regular expression.)(?!S)
,(?<!S)
For this grouping operator there is no need to describe the ordering, since only whether or not
S
can match is important.(??{ EXPR })
The ordering is the same as for the regular expression which is the result of EXPR.
(?(condition)yes-pattern|no-pattern)
Recall that which of
yes-pattern
orno-pattern
actually matches is already determined. The ordering of the matches is the same as for the chosen subexpression.
The above recipes describe the ordering of matches at a given position. One more rule is needed to understand how a match is determined for the whole regular expression: a match at an earlier position is always better than a match at a later position.
Creating custom RE engines
Overloaded constants (see overload) provide a simple way to extend the functionality of the RE engine.
Suppose that we want to enable a new RE escape-sequence \Y|
which
matches at boundary between whitespace characters and non-whitespace
characters. Note that (?=\S)(?<!\S)|(?!\S)(?<=\S)
matches exactly
at these positions, so we want to have each \Y|
in the place of the
more complicated version. We can create a module customre
to do
this:
package customre; use overload;
sub import { shift; die "No argument to customre::import allowed" if @_; overload::constant 'qr' => \&convert; }
sub invalid { die "/$_[0]/: invalid escape '\\$_[1]'"}
# We must also take care of not escaping the legitimate \\Y| # sequence, hence the presence of '\\' in the conversion rules. my %rules = ( '\\' => '\\\\', 'Y|' => qr/(?=\S)(?<!\S)|(?!\S)(?<=\S)/ ); sub convert { my $re = shift; $re =~ s{ \\ ( \\ | Y . ) } { $rules{$1} or invalid($re,$1) }sgex; return $re; }
Now use customre
enables the new escape in constant regular
expressions, i.e., those without any runtime variable interpolations.
As documented in overload, this conversion will work only over
literal parts of regular expressions. For \Y|$re\Y|
the variable
part of this regular expression needs to be converted explicitly
(but only if the special meaning of \Y|
should be enabled inside $re):
use customre; $re = <>; chomp $re; $re = customre::convert $re; /\Y|$re\Y|/;
BUGS
This document varies from difficult to understand to completely and utterly opaque. The wandering prose riddled with jargon is hard to fathom in several places.
This document needs a rewrite that separates the tutorial content from the reference content.
SEE ALSO
"Regexp Quote-Like Operators" in perlop.
"Gory details of parsing quoted constructs" in perlop.
pos.
Mastering Regular Expressions by Jeffrey Friedl, published by O'Reilly and Associates.


The Limits to Growth
"Computation and the Human Predicament," in the May–June issue of American Scientist, discusses the World3 computer model, introduced in the 1972 book The Limits to Growth. As a way of better understanding the inner structure of the model, I have been working to re-implement it as a web application. The current state of this project is on exhibit here.
This is a work in progress and may well have serious bugs. I expect to continue improving it, but any serious investigation of the World3 model should be done with one of the more reliable simulation packages, such as Stella II or Vensim. This one is a toy.
The program relies on some fairly recent additions to the HTML markup language. In my casual tests I have found that it works well in recent releases of Google Chrome, Opera and Safari; it also runs in Firefox, though more grudgingly. As far as I know, even the latest versions of Internet Explorer do not support all the features needed.
The controls for the model include four "sliders." Two of them allow for adjustments in the total duration and time resolution of the model. A third slider determines the initial quantity of nonrenewable resources, which has a major impact on the fate of the simulated world. The measure of resources displayed in the graph is the fraction remaining, so the curve will always begin at the maximum point of the y axis; but changing the setting of the resources slider alters the rate of depletion. The final slider adjusts the proportion of industrial output diverted away from investment and into consumption. Small changes in this parameter can have dramatic—and perhaps counterintuitive—effects.
I've described a few more details on the implementation of the model in a blog post: World3, the public beta.
Brian Hayes


Découvre notre école de surf en peer-learning
This is a longer card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.
This card has supporting text below as a natural lead-in to additional content.
This is a wider card with supporting text below as a natural lead-in to additional content. This card has even longer content than the first to show that equal height action.
Surfing is not a sport, it's a way of life, it's no hobby. It's a way of looking at that wave and saying, "Hey bud, let's party!"
Jeff, avril 2019
Gâce à TSP je fais le tour du monde avec mon van et fais du surf ! Si l'éxperience était à refaire je le referais plein de fois.
-Jean-Michel, octobre 2018


Salmon Cookies,
Grizzlies welcome..
Home
Sales
Shops
Seattle
Tokyo
Dubai
Lima
Estimate Cookies
Sales Data
Shop
Add New Shop Data
Shop Name:
Minimum Customers P/d
Maximum Customers P/d
Average Cookies Per Customer
Add New Shop


from: http://mylittlerapture.com/three.js/Infinite_city.html
from: https://github.com/sheab/circle-game
from: https://github.com/jpweeks/particulate-medusae


Statistics
Count
Size
VCX Libraries
1
302.0430 KB
Programs
1
136.8164 KB
Menus
1
9.4326 KB
Total
3
448.2920 KB


We have a very flexible offers for you to choose
STANDART
ICONIC GRAPHICS
$
10
Monthly
Unmetered Traffic
Unlimited Domain
Unlimited Databases
Unlimited e-Mails
ENROLL TODAY
BEST VALUE
ICONIC GRAPHICS
$
25
Monthly
PHP, PERL, ASP, JSP
SEMI DEDICATED
Staging of Production
Unlimited e-Mails
ENROLL TODAY
ULTIMATE
ICONIC GRAPHICS
$
35
Monthly
Semi Dedicated
1TB Storage
Faster Site, Better SEO
Unlimited e-Mails
ENROLL TODAY


Community
Get in touch with other people
Share your adventures or see what others are saying!
-
Check the reviews
When navigating to a specific hike or walk, see what other people think of it by checking the reviews
-
Tell your story
You can add your own photos or tips and share them with the community. They might even like or comment on your post
-
Share your adventures
When you finished a hike and want to tell your friends or family all about it, you can share it with them through Facebook, Instagram, WhatsApp and more


A trope seen in video games. Basically, a larger thing, be it a larger enemy, boss, an entire structure or sometimes even a planet, makes numerous smaller explosions scattered across its surface (often with regular time intervals) before finally making a big bang or just simply being destroyed.
Usually, mechanical constructions in Real Life don't have tens of parts that explode, especially at regular intervals. However, you might notice that many examples below are made from even less volatile material like concrete which isn't known to explode in real life at all. Some examples take it step further so now even characters made of meat and flesh can cause explosions in a similar manner, be it an alien or a pirate captain. Strangely, they often aren't carrying explosives or firecrackers with them either to justify these explosions.
It's also often observed that while explosions often appear in random places on the surface of the destroyed thing or character, they can also appear in the vicinity of the destroyed thing and not on the surface of this thing at all. Moreover, some of the exploding things themselves disappear right before the series of explosions occur, making you wonder how can explosion chain reaction occur out of thin air. That might forever be a mystery. Maybe the explosions happen because of Rule of Cool.
The origins of this trope are currently unknown but may have been initially used because of technical limitation of consoles. Making a big explosion with sprites only will bring a third generation console down to a crawl so several small explosions which appear at different time intervals, were used instead since it's much more resource-friendly to the console. Then it was noticed that it looked cool anyway and that's why we have it in games on much more powerful consoles.
The regularity of this trope is the most clearly seen in third generation and fourth generation video games with about every 16th NES game having explosions like these. After that period, the usage of this has been reduced slightly, but it's still almost always played straight since it is not very recognized trope. Usually, 2D games use chain explosions more often.
Subtrope of Stuff Blowing Up, often with Made of Explodium. They're also common in games where every enemy tends to explode.
More than 3 explosions counts as this trope. Less than that, and you're better off looking at Defeat Equals Explosion.
Not to be confused with Disaster Dominoes.
Examples from Video Games
Destruction after or with the series of explosions
- An octopus boss in Shantae: Risky's Revenge explodes that manner.
- Ellmac from La-Mulana, awkwardly, since he is a giant frill-necked lizard.
- Sometimes happens in Castlevania series. For an example, in Castlevania: Symphony of the Night both at the end of the intro with Dracula and after beating Granfalodon.
- The Legend of Zelda:
- The Legend of Zelda: A Link to the Past: Enemies and Bosses resembling segmented worms -such as Sandworms, Lanmolas and Moldorms- are known to go down in a series of small explosions.
- Twinmold in The Legend of Zelda: Majora's Mask.
- Bosses in Blaster Master series.
- Bosses in Gurumin: A Monstrous Adventure lightly explode, then slowly dissolve into light.
- Missile Command is the Trope Codifier of videogaming history. Part of the strategy is that even though you have a limited number of missiles, you try to destroy the missiles at the edge of your explosion, because their explosion can take out other missiles, causing a chain reaction of explosions. Since you get bonus points for unlaunched missiles, it also aids your score.
- Many, many bosses in Contra series. Sometimes applies to some of the other objects too.
- The final boss in TankForce.
- Bosses in Journey to Silius.
- The final boss of Dr Jekyll and Mr Hyde NES game.
- Minibosses and bosses in Low G Man.
- Bosses in Ninja Gaiden NES games.
- Some of the smaller bosses in Shadow Of The Ninja.
- Defensive walls in Shatterhand.
- Bosses in The Trolls In Crazyland .
- 2/5 of the bosses in Vice Project Doom.
- Numerous bosses in Gunstar Heroes series. Considering that even the regular enemies explode even in a more spectacular fashion than the enemies in Contra series, it's hardly surprising.
- Bosses and minibosses in Dynamite Duke
- Stronger enemies, minibosses and bosses in Alien Hominid.
- Final boss in Michael Jackson's Moonwalker.
- Bosses and in lesser extent, regular enemies in Madoo Granzort.
- Bosses in Super Bomberman.
- Minibosses, some bosses and some miscellaneous objects in X-Men Mutant Apocalypse.
- Bosses in Rocket Knight Adventures series.
- Most mini bosses and bosses in Run Saber.
- Numerous bosses in Metroid series.
- Bosses and some of the larger structures in Godzilla: Monster of Monsters.
- Bosses and barricades in Ex-Mutants.
- Non-Robot Master bosses in the Mega Man (Classic) series.
- Bosses in Cuphead explode repeatedly.
- The kaiju Wario and giant nose boss in WarioWare Inc: Smooth Moves.
- The final missile in Rush'n Attack.
- Cyborg Justice has every inch of the Final Boss explode 4 times.
- The first boss in Battletoads in Battlemaniacs.
- All of the final boss's forms in Dynamite Dux.
- Bosses in Super Spy Hunter.
- Each time a Gargantua is killed in Half Life 1, its death is marked by a series of explosions.
- Half-Life 2 does this with Gunships.
- Happens every time a boss is defeated in Reelism.
- The force field generators in Combat Instinct 1, and the warpgate in 2.
- The Icon of Sin in Doom 2.
- The Kilmaat Queen's second form in Powerslave.
- The bosses in ActRaiser
- The bosses in Moon Crystal. It's strange because large part of the bosses are living creatures.
- Bosses in NES version of Joe & Mac. Notable that the bosses are dinosaurs.
- One of the castles in Super Mario World.
- Half of the bosses in The Flintstones - The Rescue of Dino and Hoppy. Besides the final boss, other bosses are not mechanical at all. In the sequel, that won't happen since bosses seem to fall through the floor.
- Many minibosses in the original Mega Man (Classic) series.
- A few bosses of Conquest Of The Crystal Palace.
- Bosses in Little Nemo: The Dream Master.
- Bosses in Little Samson carry explosives around too in case they get killed.
- Bosses in Silent Assault.
- Bosses in Jazz Jackrabbit have red chain of explosions accompanied by sparks.
- Third and both phases of the fifth boss in Mr. Gimmick.
- Bosses in Ninja Crusaders.
- A large robot dog and Shredder in the first Teenage Mutant Ninja Turtles NES game.
- Most of the bosses in Vectorman series.
- A lot of the bosses in Gargoyle's Quest series. One of its sequels, Demon's Crest, takes it further when even the regular enemies qualify.
- The floating island in the end of chapter 6 of Super Meat Boy with the help of Self-Destruct Mechanism.
- Bosses in Decap Attack
- Many bosses, minibosses and pieces of scenery in Dynamite Headdy.
- Bosses in Earthworm Jim.
- Most bosses in Earnest Evans.
- Bosses in Ghouls 'n Ghosts.
- Bosses in Spinmaster, organic ones included.
- Some bosses in Kirby series are borderline that but a few of them (like Wham Bam bosses) are true examples. Explosions are replaced with pentagrams though.
- The first and third bosses of Bug Justified for the first boss, since the giant snail's shell acts like a helicopter bomber, not so justified for the giant swamp worm.
- Except for the Teki trio, most bosses and stuff blows this way in Cannon Dancer.
- All bosses in two out of the three games which form part of Three Wonders: Midnight Wanderers and Chariot.
- Bosses in Meikyuujou Hydra.
- Bosses in Mitsume ga Tooru.
- Bosses in My Little Pony Rise Of The Clockwork Stallions.
- Bosses in Chakan: The Forever Man.
- Bosses in Pulseman.
- Bosses in Ultraman Club.
- Normal enemies in The Great Battle IV.
- The train boss, Godzilla, and the final boss in The Revenge of Shinobi.
- Several unit and building death animations in Starcraft II
- The Burrowing Snargets in Pikmin
- Bosses in Faxanadu.
- Secret of Evermore bosses get the "simple destruction" variation.
- Bosses in Adventure Kingdom though, with one last large explosion in the end before destruction.
- The final boss of Blue Dragon sinks into lava while numerous explosions erupt across his body.
- Final boss in Galaga '88.
- Bosses and walls in Heavy Barrel.
- Both phases of final boss in Jackal
- Bosses in Iron Tank.
- A few bosses and minibosses in Legendary Wings.
- Bosses in S.C.A.T.. Rather long variation.
- Bosses in Section Z.
- Bosses in Silkworm.
- Bosses in Star Soldier.
- Many bosses in Metal Slug series.
- Bosses in Air Buster. Rather humble variety.
- Bosses in Arrow Flash.
- Bosses in Elemental Master.
- Bosses in Granada.
- Larger enemies, barricades and bosses in Mercs.
- Bosses in Twinkle Tale.
- Bosses and minibosses in Axelay.
- Larger enemies in Bio Metal.
- Bosses in Forgotten Worlds.
- Bosses in the first Darius.
- Bosses and structures in Raptor: Call of the Shadows will suffer from multiple explosions once they have taken enough damage. The buildings themselves have sequential explosions that move from one end to the other, interestingly.
- Bosses in Guxt.
- Bosses in Midnight Resistance.
- Algeroth, the final boss of Doom Troopers.
- Destroying a ship in FTL: Faster Than Light makes it give off a few explosions before falling apart.
- Bosses in Ufouria. The Final Boss takes it Up to Sixteen.
Series of explosions after destruction
- 3/5 of the bosses in Vice Project Doom.
- Large normal enemies in Super Metroid turn into a cloud of explosions upon defeat.
- Bosses in Metal Storm turn into a whole screenful of the best 8-bit explosions ever.
- Oddly, in Monster Party normal enemies die like this, but not the bosses who just fade away.
- Regular enemies in Gremlins 2, although the series of explosions is rather silent.
- Bosses in Kabuki Quantum Fighter.
- The final boss in Karnov
- Bosses and minibosses in Adventure Island II, III and IV.
- Bosses in Totally Rad.
- A few of the bosses in Vectorman series.
- Bosses in Batman and Batman: Return of the Joker.
- "Bosses" in BIT.TRIP Beat.
- In Tank Wars, one of the most satisfying things that could happen was seeing your post death explosion take out the tanks that killed you.
Big boom at the end
- The AK supertank boss in TankForce.
- Bigger bosses in Shadow Of The Ninja.
- Bosses and a few minibosses in Shatterhand.
- Bosses in Mega Man 8. and Megaman 11.
- Some large Lambent in Gears of War 3.
- Bosses in Axiom Verge are covered with eight-bit explosions, and then massively explode into paint in slow-motion.
- Most bosses in The Binding of Isaac die in a more meaty version of this.
- Stage bosses in Blazing Chrome turn into a huge, slowly expanding fireball.
- The first planet in Super Metroid.
- Major Cave Story and Guxt bosses.
- Bosses in The Legend of Zelda: The Minish Cap, The Legend of Zelda: Four Swords Adventures and The Legend of Zelda: A Link Between Worlds.
- Bosses in Castle In The Darkness explode all over while spouting coins, then burst into a ring of sparkles.
- Liquid Snake's Hind helicopter in Metal Gear Solid.
- Every mechanical boss in Teenage Mutant Ninja Turtles: Turtles in Time, and Cement Man in the arcade version. Also, every boss in The Hyperstone Heist.
- The floating baseball stadium dropship in the final stage of Ninja Baseball Batman.
- Opponents in Tech Romancer.
- The destroyer boss in Combat Instinct.
- The main enemy base in the ending of Bionic Commando.
- A few bosses in Demon's Crest.
- Bosses and minibosses in Purple do this with stars instead of flames.
- Bosses in the Mega Man Zero and Mega Man ZX series.
- All bosses in Mega Man X7 and Mega Man X8. Also, X1's fortress bosses.
- Wily's castle and it's bosses in Mega Man 7.
- Multiple mechanical bosses in both Super Mario Galaxy games.
- The bosses of Lyle in Cube Sector go out like this. The final boss exploding is also how Lyle escapes the pit he and the boss fell into.
- Wily's escape pod at the end of Mega Man II.
- Bosses in Kero Blaster.
- In Super Robot Wars, almost everyone explodes with several small explosions followed by a big one. Even living beings like the Radam beasts.
- If you upgraded the Normandy's main gun in Mass Effect 2, the Collector cruiser explodes this way once your Cool Starship gets through with it.
- Bosses in DonPachi.
- Minibosses and bosses in Gun Nac.
- Bosses in Ikaruga.
- Capital chips in Zanac.
- Bosses in Mushihime Sama series.
- Bosses in Gaiares.
- Bosses in M.U.S.H.A..
- Many bosses from Fraxy.
- A planet at the beginning of S.C.A.T..
- Bosses in Bio Metal.
- Bosses in Raiden games.
- Star Fox 64 has the train boss crashing into a weapons depot in The Scottish Planet, demonstrating the (at the time) newfangled rumble feature like few games have since. Made all the more satisfying in that going to the planet and the train's demise are both optional.
- Bosses in Hero Core.
- Any ship in Escape Velocity will suffer a series of secondary explosions at random intervals, the duration of said series dependent on the ship's DeathDelay stat. If said stat is more than 60 frames, the ship blows up in a huge explosion that damages anything in a radius dependent on the ship's mass.
- Bosses in later games in the Darius series.
- Everything bigger than a fighter in FreeSpace. The bigger the ship, the more little explosions go off before the big boom that typically splits the whole ship in half.
- XCOM: Enemy Unknown: Sectopods explode four times when destroyed. With Enemy Within running, the last explosion deals considerable damage up to four tiles away.
Series of explosions followed by big white flash
- Some bosses in Cave Story.
- In Obsidian, if you decide to use the Crossover Switch to crash Ceres' systems, the AI's entire world self-destructs bit by bit, while the Conductor lets out a Big "NO!", before she too explodes in a white flash, ending with the Obsidian structure destroyed and you and Max returned to reality.
- Bosses in the Mega Man X 1-6. X4 and X5 use Akuma's trademark Finishing Move sound effect, just so you know they didn't live through it.
- Major story bosses (mostly the Bonne fights) in Mega Man Legends.
- Bosses in Shantae and the Pirate's Curse.
- Bosses in The Great Battle IV.
- The Magician in House of the Dead.
- Bosses in Secret of Mana.
- Destromon in Digimon World 3.
- Bosses in the later Ys games.
- Malthael from Diablo 3, but replace "explosions" with "escaping souls."
- Some bosses in Hydorah.
- Capital ships and space stations in the X-Universe series suffer two or three secondary explosions, then one enormous flash that completely disintegrates ships and leaves a burned-out hulk behind in the case of most stations. Anything corvette-size or smaller explodes immediately in a small fireball, averting the trope. The explosions do no damage in the vanilla game, though various Game Mods such as Xtended add it.
- Capital ships in X Rebirth will have dozens of explosions go through their hull, then a massive implosion followed by an explosion as the jumpdrive goes critical. Ships near the explosion take massive damage.
Series of explosions followed by something other
- Without actually exploding himself, Balrog from Cave Story does this.
- Bosses in Metroid Fusion are consumed in explosions before pixellizing into their Core-X forms.

- Most bosses in Chaos Legion are covered with dozens of fiery explosions and then simply die.
- Castlevania: Aria of Sorrow's true ending has the castle explode repeatedly before imploding.
- In Gundam Wing Endless Duel, defeated fighters collapse while repeatedly exploding.
- Bosses from Radiant Silvergun spout fiery explosions and then implode into a tiny ball of light.
- Final boss transforms back in to normal Dr. Chaos after series of explosions.
- Tor's Humongous Mecha in Iji first has various parts exploding, then what's left disappears with the same special effect it appeared with.
- The three Captain Syrup final bosses in Wario Land 2 explode repeatedly before both Syrup and her machine fall off the screen.
Examples from Other Media
Anime & Manga
- In Mobile Suit Gundam Wing, Space Fortress Barge does this after having its main cannon cleaved open by Zechs Merquise and Epyon's beam saber.
- Inuyasha: Sesshoumaru's true sword, Bakusaiga, utterly destroys everything it cuts, and everything that touches what it cuts.
- Tengen Toppa Gurren Lagann loves this.
Film
- Two examples from Star Wars:
- The second Death Star in Return of the Jedi exhibits this before its final explosion.
- In The Phantom Menace, the Trade Federation ship explodes at random points all over its hull before engulfing the command section after Anakin puts two proton torpedoes into one of the reactors.
- In War of the Worlds, Ray sticks a grenade into a tripod. The tripod then explodes repeatedly and falls over.
- At the climax of Guardians of the Galaxy Vol. 2, Planet Ego goes out with a massive chain reaction after Groot's bomb explodes on the core.
- Green Lantern: Hal Jordan punches Parallax into the sun, causing him to repeatedly explode.
- The ICSS's self-destruct sequence in Geostorm is this.
Live Action TV
- In the Stargate-verse it is a preferable destruction animation of ships destruction but these explosions hardly count as small.
- Power Rangers Monster of the Week types tend to spark a lot before dramatically falling and then going up in a huge ball of explodium.
- The villain in the Kamen Rider Hibiki movie goes out this way.
- This is how Batsu of Tomica Hero Rescue Force goes out.
Pinball
- When you sink a ship in Black Rose, it explodes several times before sinking for good.
- In Samurai Jack, this is how Aku finally goes out.
Real Life
- Fireworks factory and fireworks or munitions storage explosions are some of the closest it's possible to get to this trope without deliberately setting it up.
- This is how several real life aircraft carriers were lost during World War II (and how the USS Forrestal was nearly lost after an accidental fire during the Vietnam War). An aircraft carrier in wartime has a lot of explosive stuff lying around both on and below flight decks (bombs, fuel lines, bombed-up and fueled-up aircraft, etc.) If there is a fire, there is a good chance that fire would spread to these incendiary objects, start a chain reaction, and lead to catastrophic results.
- Note that ideally, said flammable/explosive things are kept safely stowed away (preferably in protected areas away from each other), but certain operations necessitate moving them to more exposed areas, such as arming and launching aircraft, or moving ammunition from the magazine to the guns. Several Real Life examples of ships being destroyed due to this trope were the result of unsafe practices meant to more quickly move the process along (this was infamously how several of the Royal Navy's battlecruisers met their untimely end at the Battle of Jutland.)
- The Deepwater Horizon/Macondo blowout and explosion is a modern textbook example of this trope as well as being a case of Disaster Dominoes:
- The well casing cement fails, allowing wellbore pressure to rise beyond manageable levels.
- The blowout preventer's annular fails to contain the pressure. The well blows out on the rig floor, venting wellbore contents.
- The MGS (Mud-Gas Separator, also called a Gasbuster) fails to keep up with the volume of gas in the mud being pushed out of the well. This causes a fail-deadly situation as gas begins to build up around the platform, particularly around the wellhead.
- Gas is sucked into the platform generator air intakes, causing generators to overspeed until they explode.
- The fire flashes back to the wellhead.
- The accumulated gas cloud on the drilling floor and surrounding the platform explodes. This entrenches the fire that will ultimately cause the platform to sink.
- Decades ago, before the currently accepted models of supermassive black holes and/or large-scale star formation concentrated there fueling them, it was proposed that supernova chain reactions would power active galactic nuclei as quasars.
- Today, more accurate modeling reveals that individual supernovas are often examples of this trope, with their intensity and duration coming from rapid (on the cosmic scale) cycles of collapse, explosion, and re-collapse of the remaining matter over several hours, days, or weeks until enough kinetic energy has been bled off to collapse fully into a black hole or stellar remnant.


Filter
class that filters for tasks containing the provided search
terms.CommandHandler
which handles searching for Task
objects
containing one or more specified search terms.Task
object.StorageInterface.setDataFile(File)
which
sets the provided File
object as the new FunDUE data file.File
object and updates
the user's data file path preference.Task
object.Task
object.Logic
.CommandHandler
requires a display refresh after
execution.UIInterface.showChangeDataFilePathDialog()
which shows a file picker dialog to let the user choose a new FunDUE data
file.UIInterface.showHelpPage()
which shows the
FunDUE Help Page window.StorageInterface
component for testing purposes.StorageInterface
component that contains test cases for the
Storage
class.Task
list into the undo stack.Task
objects into the
undo stack.Task
list into the redo stack.Task
list into the redo stack.