Top 1 deals for Aba Software Software

Unix time is the number of seconds elapsed since midnight UTC on January 1, 1970. For example, Unix time was 17‍56684800 on September 1, 2025 at midnight UTC. The counter is independent of the time zone, holding the same value at the same moment in different timezones. It is widely used in C and C++ programming languages, databases (MySQL, PostgreSQL, and SQLite), and file systems (ext3, HFS+, and Reiserfs).

Unix timestamp now is: .

The counter is typically stored in a 32-bit signed integer, so it can represent dates from December 13, 1901 to January 19, 2038. In 2038, the counter will reach 2³¹−1 and overflow, which is known as the year 2038 problem. Fortunately, most modern implementations have already switched to 64-bit integers.

Java and JavaScript use the number of milliseconds, not seconds, to represent time since 1970, resulting in a counter with more digits (e.g., 17‍56684800000) that fits in a 64-bit integer. Some other implementations (e.g., Apple File System) count the number of nanoseconds instead.

The Unix developers chose the epoch of January 1, 1970 because they created the first version of Unix in 1970, so they only needed to represent dates after 1970. Other platforms chose a date close to the introduction of the Gregorian calendar, for example, the Windows counter (the FILETIME structure) starts on January 1, 1601 and the UUID version 1 counter starts on October 15, 1582.

You can use the following functions in different programming languages to get the current Unix timestamp value:

• in C/C++, use time_t timestamp = time(NULL);
• in PHP, use echo time();
• in Python, use:

import time, math
print(math.ceil(time.time()))
    

• in JavaScript, use Math.ceil(Date.now() / 1000);
• in Java, use long timestamp = System.currentTimeMillis() / 1000;
• in Go, use:

import "time"
timestamp := time.Now().Unix();

• in MySQL, use select unix_timestamp();
• in PostgreSQL, use select ceil(extract(epoch from current_timestamp));
• in SQLite, use select strftime('%s');

Aba Search and Replace can convert Unix/JavaScript timestamps to a date in popular formats including ISO 8601 / RFC 3339, RFC 1123 / RFC 7231, and the Windows system format. It can also perform the reverse conversion and generate the current timestamp.

Here is another practical task. We need to replace only the second or following match in each file.

For example, we want to insert <a name="..."> tags before the second and any subsequent headers in each HTML file. There are multiple headers in each file:

And we want to insert a name to be able to refer to each header. The final result should look like this (the added tag is bold):

<a name="international_search_test"><h2>International search test</h2>

We can solve this task with a lookbehind:

(?<=<h2>.*?)<h2>

This regular expression matches <h2>, but only if there is another <h2> before it.

With Aba Search and Replace, there is a more flexible way to do this. You can match all <h2> tags, but change only the second, the third, etc. tags leaving the first tag intact. The pattern is simple:

<h2>(.*?)</h2>

But in the replacement, we check if the match number is equal to one:

\( if Aba.matchNoInFile() == 1 {
   \0
} else {
   '<a name="' \1.replace(' ', '_').toLower() '">' \0
} )

If yes, we return the whole match \0 without any change. If not, we add <a name="..."> before it. We also use the toLower function to convert the name to lowercase and the replace function to replace spaces with underscores.

You can easily modify this one-liner to replace the first three tags in each file only, or replace every second tag, which is more complicated with a lookbehind.

The new version goes beyond just search and replace; it allows you to convert text and images to and from Base64, encode and decode HTML entities like <, encode and decode percent-encoding (also known as URL encoding), decode JSON Web Tokens, and convert Unix/JavaScript timestamps to dates and vice versa.

Other new features and fixes include:

• Fixed: a long file name was cut in the combobox (many thanks to Duane who reported the bug).
• An option to disable the dot matches newline mode (the \s modifier; thanks to Helmet for the idea).
• Line numbers in the text viewer (thanks to Yonatan).
• An option to preserve the files' date/time (thanks to Duane).
• Syntax highlighting for Scala and Go.
• Ctrl+1, Ctrl+2, etc. to switch between the tabs.
• Updated translations.
• Fixed: when reading from disk failed, Aba crashed (mostly applicable to old HDDs and network drives).
• Fixed: incorrect cursor position for Chinese characters.
• Fixed: excessive completion sound when the search pattern was changed.
• Fixed: in the Undo > In files field, the vertical scrollbar was displayed for long directory names.
• Fixed: in some cases, a previous file name remained in the status bar when the search did not find anything.

Just as always, the upgrade is free for the registered users.

Sometimes, you need to remove personal data from a dataset, such as when preparing examples or unit tests. With Aba Search and Replace, you can mask names, addresses, and other personally identifiable information by replacing them with counters.

Let's use the following CSV file with information about Alice in Wonderland characters as an example:

Name,Address,Favorite Color
Alice,Near the Rabbit Hole,Blue
Mad Hatter,Tea Party Garden,Orange
White Rabbit,Rabbit Hole,White
Queen of Hearts,Hearts Castle,Red
Cheshire Cat,Forest Tree Hollow,Purple
Caterpillar,Mushroom Grove,Green
Tweedledee,Looking Glass Land,Yellow
Tweedledum,Looking Glass Land,Yellow
March Hare,Mad Tea Party Estate,Brown
Dormouse,Tea Party Garden,Gray

You want to remove real names and addresses from this file. A common approach would be to write a script that opens the file, reads each line, replaces the first two fields with counters, and then prints the result. However, it's easier to do the same task with Aba Search and Replace. You don't have to write boilerplate code for file reading, and you can immediately preview the replacement results.

We'll use the following regular expression to match the first two columns in the CSV file while skipping the headers:

(?<=\n)(\N+?),(\N+?),

Here's how it works: first, we check that a newline \n is found before the match using a lookbehind assertion, which allows us to skip the headers (the first line). Next, we match two fields separated with commas.

We would like to replace the names (Alice, Mad Hatter, White Rabbit, etc.) with a counter like person1, person2, person3, etc. Aba provides functions for inserting counters; Aba.matchNo works well for this case:

For the address field, we don't want to use the same sequence (1, 2, 3), so let's do some math with the counter in order to start from 77 and decrement each street number by 3. The replacement expression becomes:

person\{ Aba.matchNo() },\{ 80 - Aba.matchNo() * 3 } Wonderland Drive,

Note that proper anonymization is more complex than this. In our example, it's still possible to identify some characters after the replacement. For example, White Rabbit predictably likes white, Queen of Hearts likes red ❤️, and the twins (Tweedledee and Tweedledum) share the same favorite color, yellow. So the anonymization process won't meet GDPR requirements and you need further manual edits to remove or randomize such cases, but the replacement is a good first step for removing sensitive information.

If you set the width and height attributes for your img tags, the browser can allocate the correct amount of space for the image before loading it. This prevents content below the image from shifting around as the page loads. The layout becomes stable, which means that:

• your users won’t accidentally click a wrong button because of layout shift;
• the performance is better because the browser doesn’t have to recalculate the layout as the images load;
• page load feels smoother and faster.

That’s why Google recommends setting the width and height attributes in your HTML code.

If you have a lot of images, it may take some time to specify their dimensions. With Aba Search and Replace, you can do it automatically.

The typical case

Please use this search pattern to capture the image file name in the first subexpression:

<img src="([^"]+)"

The [^"]+ regex matches everything except for the closing quotation mark and parentheses mark the first subexpression.

If you have absolute paths like <img src="/images/someImage.png"> in your HTML code, use the following replacement:

\0 \{ File(Aba.searchPath() \1).meta('ImgTag') }

Here, we insert the whole match \0, which is the img tag and its src attribute. Then, we insert width and height via the meta function. The Aba.searchPath() function returns the directory that you selected for the search, then the image filename \1 is added to it.

Relative paths

If your paths are relative to the html files (e.g., <img src="someImage.png"> or <img src="../banner.png">), then use a simpler replacement:

\0 \{ File(\1).meta('ImgTag') }

Replacing existing width and height attributes

If you have existing width and height attributes and you want to replace them, the regex becomes more complex. For example, if the width and height always follow the src attribute:

<img src="([^"]+)" width="\d+" height="\d+"

And the replacement should be:

<img src="\1" \{File(Aba.searchPath() \1).meta('ImgTag')}

Matching tags without existing width and height attributes

More often, you need to skip the tags that already have the width or the height attribute. Our previous regular expression also has these disadvantages:

• If another attributes like alt precedes src, the regex won't match.
• If there are line breaks or multiple spaces between <img and src, the regex won't match.
• You need to choose between absolute paths and relative paths manually.
• If the file name contains encoded spaces, for example, Fancy%20logo.png, Aba won't be able to open the image file.

The following regular expression fixes these problems:

<img\s+(?:alt="[^"]*?"\s+)?src="([^"]+)"(?!\s+width|\s+height)

And the replacement should be:

\0 \{ File( if \1[0] == '/' { Aba.searchPath() } else {''} \1.decodeUrl()).meta('ImgTag') }

We use alt="[^"]*?" to match an optional alt attribute. If you use other attributes, you can add them here. Instead of spaces, we use \s+ to match any number of spaces or line breaks. The regular expression includes a negative lookhead (?!\s+width|\s+height), so it skips the tags that already have width or height attributes.

The replacement checks if the first character of the file name is a slash /; if yes, it uses the absolute path. Finally, the decodeUrl function replaces %20 with spaces.

This regular expression works in most cases and it's included into favorites by default. Note that regex matching is textual, so the program does not really understand HTML. You may need to modify the regular expression to match your specific case.

Conclusion

You can preview the replacements and check that the img tags are matched correctly. If Aba cannot find an image file, it will display an error message with the src attribute and the HTML filename. Then, just press the Replace button and test the result in your browser. If anything goes wrong, you can always undo the replacement.

Aba can help you to ensure that all of your pages use width and height attributes, which improves performance, prevents layout shifts, and makes your website more visually appealing for the users.