A more .net style function for getting a window using an indexOf:

    ''API Imports
    <Runtime.InteropServices.DllImport("user32.dll", CharSet:=Runtime.InteropServices.CharSet.Auto)> Private Shared Sub GetClassName(ByVal hWnd As System.IntPtr, ByVal lpClassName As System.Text.StringBuilder, ByVal nMaxCount As Integer)
    End Sub
    <Runtime.InteropServices.DllImport("user32.dll", CharSet:=Runtime.InteropServices.CharSet.Auto)> Private Shared Function FindWindow(ByVal lpClassName As String, ByVal lpWindowName As String) As IntPtr
    End Function

    ''FoundWindow stricture
    Public Structure FoundWindow
        Dim strWindowName As String
        Dim strClassName As String
        Dim hWnd As IntPtr
    End Structure

    ''' <summary>
    ''' This function is used to loop through all running processes, checking their main windows to see which ones contain a specific string
    ''' </summary>
    ''' <param name="strIndexOf">The string that you wish to check for in the window captions</param>
    ''' <param name="boolCase">Whether the function is should check for case</param>
    ''' <returns>A list of FoundWindow's containing the window name, class and handle</returns>
    ''' <remarks>As this function only loops through running processes main windows, it may miss some windows.</remarks>
    Public Function FindWindowsIndexOf(ByVal strIndexOf As String, ByVal boolCase As Boolean) As List(Of FoundWindow)
        Dim foundWindows As New List(Of FoundWindow)
        If boolCase = False Then
            strIndexOf = strIndexOf.ToLower
        End If
        For Each p As Process In Process.GetProcesses
            Dim windowCaption As String = p.MainWindowTitle
            If boolCase = False Then
                windowCaption = windowCaption.ToLower
            End If
            If windowCaption.IndexOf(strIndexOf) > -1 Then
                Dim foundWindow As New FoundWindow
                foundWindow.hWnd = FindWindow(vbNullString, p.MainWindowTitle)
                foundWindow.strWindowName = p.MainWindowTitle
                Dim sbClassName As New System.Text.StringBuilder("", 256)
                GetClassName(foundWindow.hWnd, sbClassName, 256)
                foundWindow.strClassName = sbClassName.ToString
                foundWindows.Add(foundWindow)
            End If
        Next
        Return foundWindows
    End Function

    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        For Each fWnd As FoundWindow In FindWindowsIndexOf("TeST", False)
            Debug.WriteLine(fWnd.strWindowName & " : " & fWnd.hWnd.ToString)
        Next
    End Sub

Same as the last function, you can choose whether or not the function is case sensitive.

Somebody on VBForums was asking how to do something similar to this, so after answering his question, I created this fairly useful function – for windows that names change each time you load them up or something…

    ''API Declarations
    Private Declare Function EnumWindows Lib "user32" (ByVal lpEnumFunc As EnumWindowProc, ByVal lParam As IntPtr) As Integer
    Private Declare Function GetWindowText Lib "user32" Alias "GetWindowTextA" (ByVal hwnd As Integer, ByVal lpString As System.Text.StringBuilder, ByVal cch As Integer) As Integer
    Private Declare Function GetWindowTextLength Lib "user32" Alias "GetWindowTextLengthA" (ByVal hwnd As Integer) As Integer
    <Runtime.InteropServices.DllImport("user32.dll", CharSet:=Runtime.InteropServices.CharSet.Auto)> Private Shared Sub GetClassName(ByVal hWnd As System.IntPtr, ByVal lpClassName As System.Text.StringBuilder, ByVal nMaxCount As Integer)
    End Sub

    ''EnumWindow Callback Delegate Function
    Private Delegate Function EnumWindowProc(ByVal hwnd As Integer, ByVal lParam As IntPtr) As Boolean

    ''Found Window Structures
    Public Structure FoundWindows
        Dim boolCase As Boolean
        Dim strFindWindow As String
        Dim lstFoundWindows As List(Of FoundWindow)
    End Structure
    Public Structure FoundWindow
        Dim strWindowName As String
        Dim strClassName As String
        Dim hWnd As IntPtr
    End Structure

    ''' <summary>
    ''' ''EnumWindow Callback Function
    ''' </summary>
    ''' <param name="hwnd">Current windows handle</param>
    ''' <param name="lParam">Contains the FoundWindows structure</param>
    ''' <returns>The function passes the currently found windows in the lParam using a GCHandle to reform the data</returns>
    ''' <remarks>This function is called for each of the windows found, and is where the indexOf is called</remarks>
    Public Function EnumWindowsProc(ByVal hwnd As Integer, ByVal lParam As IntPtr) As Boolean
        Dim foundWindows As FoundWindows = CType(System.Runtime.InteropServices.GCHandle.FromIntPtr(lParam).Target, FoundWindows)
        Dim windowTitle As String = foundWindows.strFindWindow
        Dim wndTxtLen As Integer = GetWindowTextLength(hwnd)
        If Not wndTxtLen = 0 Then
            Dim sb As New System.Text.StringBuilder("", wndTxtLen + 1)
            GetWindowText(hwnd, sb, sb.Capacity)
            Dim windowCaption As String = sb.ToString
            If foundWindows.boolCase = False Then
                windowCaption = windowCaption.ToLower
                windowTitle = windowTitle.ToLower
            End If
            If windowCaption.IndexOf(windowTitle) > -1 Then
                Dim foundWindow As New FoundWindow
                foundWindow.hWnd = CType(hwnd, IntPtr)
                Dim sbClassName As New System.Text.StringBuilder("", 256)
                GetClassName(foundWindow.hWnd, sbClassName, 256)
                foundWindow.strClassName = sbClassName.ToString
                foundWindow.strWindowName = sb.ToString
                foundWindows.lstFoundWindows.Add(foundWindow)
            End If
        End If
        Return True
    End Function

    ''' <summary>
    ''' This function is used to loop through all open windows and check which ones contain a specific string
    ''' </summary>
    ''' <param name="strIndexOf">The string that you wish to check for in the window captions</param>
    ''' <param name="boolCase">Whether the function is should check for case</param>
    ''' <returns>A FoundWindows structure containing a list of FoundWindow</returns>
    ''' <remarks>The FoundWindows structure also contains the strIndexOf that was used to search the windows caption</remarks>
    Public Function FindWindowsIndexOf(ByVal strIndexOf As String, ByVal boolCase As Boolean) As FoundWindows
        Dim foundWindows As New FoundWindows
        foundWindows.boolCase = boolCase
        foundWindows.strFindWindow = strIndexOf
        foundWindows.lstFoundWindows = New List(Of FoundWindow)
        Dim ListHandle As System.Runtime.InteropServices.GCHandle = System.Runtime.InteropServices.GCHandle.Alloc(foundWindows)
        Try
            EnumWindows(AddressOf EnumWindowsProc, System.Runtime.InteropServices.GCHandle.ToIntPtr(ListHandle))
        Finally
            If ListHandle.IsAllocated Then ListHandle.Free()
        End Try
        Return foundWindows
    End Function

    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        For Each fWnd As FoundWindow In FindWindowsIndexOf("Test", True).lstFoundWindows
            Debug.WriteLine(fWnd.strWindowName & " : " & fWnd.hWnd.ToString)
        Next
    End Sub

The function can check for casing as well. For example if you are running two windows one named “test” and another named “Test” if you use the function like this:

FindWindowsIndexOf("Test", True)

It will only return one window, however if you set the boolCase to false:

FindWindowsIndexOf("Test", False)

It will return both windows

Can you find the substring?

In older procedural languages, the return values that came back from a function were restricted. If you said you were going to return a number, you returned a number. If you wanted to sometimes return a number, but other times return an indication of failure, you resorted to what is known as a “sentinel value” to return the failure.

A sentinel value is a number that doesn’t represent the answer to the problem that the function was asked to solve, but instead flags the caller to the fact that something rather out-of-the-ordinary has happened. For example, a value of -1 can indicate the end of a file being read in.

The problem with a sentinel is that it means nothing special to the language. The programmer has to keep in mind that the sentinel exists and that it has to be handled on every call that could possibly generate the sentinel value. Programmers are notorious for paying attention to and handling sentinels only when they crash a program.

Also, the programmer has to be careful in choosing the value. Is it 0? -1? 99? 255? 999? -999? MAXINT? The choice can bite you if you’ve misunderstood the possible values that can be generated in your function. I regret to inform you that I once wrote a BASIC program that had three different sentinel values returned from three different subroutines!

Sentinel values sound old and busted, don’t they? Their usage fell a bit once we could pass around pointers to data structures. With a little more elbow room, we could put a “success” boolean right up front in the data structure and do away with a lot of sentinels.

They Live!

But sentinels are still around. In JavaScript, the string method “indexOf” returns a -1 if the needle (substring) can’t be found in the haystack (the string to be searched).

Let’s look at a few different ways we can deal with that awkward -1.

function wrappedIndexOf(needle,haystack) {
    var res=haystack.indexOf(needle);
    if (res===-1) {
        res=false;
    }
    return res;
}

And you call it like this:

res=wrappedIndexOf(needle,haystack);
if (res!==false) {
    location=res;
}

We haven’t done much here but replace the need to check explicitly for -1 with a need to check explicitly for false. Too weird to sometimes return a number and sometimes return a boolean? Yeah, probably. I like it a bit better than the numeric sentinel because the calling code makes the exception check a bit more obvious. Because JavaScript functions can return just about anything (including wild things like anonymous functions), you always need to think about what can come out of a function, so what’s important is a consistent convention.

Similarly, you could return null or undefined.

But let’s move on to another solution–returning an object.

function wrappedIndexOf(needle,haystack) {
    var res=haystack.indexOf(needle);
    if (res===-1) {
        res={"success":false,"value":-1};
    } else {
        res={"success":true,"value":res};
    }
    return res;
}

And you call it like this:

obj=wrappedIndexOf(needle,haystack);
if (obj.success) {
    location=obj.value;
}

Note that I’ve left the -1 in obj.value, so you can still use that as a sentinel if you like.

What makes JavaScript really good for this task? Its object literals. You don’t need to have a structure or class around to hold the extra info. You just build the object on the fly and return it.

There were many functions we used to parse strings in Classic ASP, like Mid, Right, Left, Instr and Len. But now there are new items – properties assigned to the strings, like Substring, IndexOf, EndsWith, and StartsWith.

Before, we had mid and right. Now we have ‘SubString‘. In Classic ASP, to parse just a bit of a string, from a certain position in the string, we would use :

Dim sItem
sItem="This is my String"
Mid(sItem,5)

This would start 5 characters into the string, and give you what was left. The new way to do it is with the SubString Property. Here’s how you use it for the same function:

Dim sItem as String
sItem="This is my String"
sItem.SubString(5)

What you would end up with is ‘is my String’.

One other variation of the SubString property will allow you to start at a certain character (from the left) of the string, and parse the string by a certain number of characters past that starting point. In other words, you could do this:

Dim sItem as String
sItem="This is my String"
sItem.SubString(5, 9)

The text you would end up with would be ‘is my str’. It started at the 5th character in from the left of the string (just before the word ‘is’) and proceded to crop/parse the text for another 8 characters.

We also previously had the instr function, which, by using it, could find the position in the string of another string. For instance, if the string was “Where is the big black dog?” and we wanted to find the position (in that string) of the word “the”, we would use the instr function. To do this, the cleanest way possible, we’d assign the entire string to a variable (let’s call it ’sItem’), then, the code would look something like this (including the use of the position, after finding it):

Dim lg
lg=instr(1, sItem, "the")
response.Write (lg)

Then, of course, we could response.Write lg or use lg in any way we wanted, from there.

Now, we have the indexof property. It’s a little simpler – a little cleaner. Let’s use the same string (sItem):

Response.write (sItem.IndexOf(“the”))

Another variation of this would be more like the original instr function, it finds the position of a particular string, based on a starting location in that string.

Response.write (sItem.IndexOf(“the”, 5))

This would actually look for the position of the word ‘the’, but it would start looking at the 5th character position.

There are two new items we’ll look at now. They are ‘EndsWith‘ and ‘StartsWith‘. I’ll only go into the explanation of ‘EndsWith‘, because after that, ‘StartsWith‘ will be self explanatory. The return value is a boolean in this case, and not a numeric position in the string. Let’s say sItem, in this case, is ‘We’re really having fun now!”. What these two properties do is check for certain strings or characters and, if the string ends with or starts with that character or string, the return is ‘True’. Otherwise, of course, the return is ‘False’. Here’s how you would use it:

Response.Write (sItem.EndsWith(“!”))

Naturally, in this case, it would return ‘True’.

One last thing we need to look at in this tutorial is the replacement for ‘Len‘. In Classic ASP, we’d write:

response.Write (len(sItem))

In ASP.Net, it’s a little different – as before, each string is an ‘object’. Therefore, you assign the length property to it:

response.Write (sItem.Length)

The Compare property is a pretty neat addition to ASP.Net and works in a a couple of different ways. In each case, lets go with the fact that sFirstItem is “Chevy” and sSecondItem is “Ford”. Here’s the basic format in which you would see it used:

String.Compare(sFirstItem, sSecondItem)

This, of course, shows you the format using variables, which is more like what will be encountered in day to day programming. You could use exact strings also, with double-quotes around each item. However, since they are exact strings, In the Classic ASP days, we’d need to attack it something like this:

if sFirstItem=sSecondItem then
	response.Write ("It's a Match")
else
	response.Write ("It's Not a Match")
End If

It’s not really more compact in ASP.Net, but here’s the way it’s utilized:

if String.Compare(sFirstItem, sSecondItem) =0 then
	response.Write ("It's a Match")
else
	response.Write ("It's Not a Match")
End If

By default – this compare method is NOT case-sensitive. However, you have the option to ‘turn-on’ case-sensitivity, if the requirements dictate such. To do so, you would add a third argument “True” to the comparison. The format of the first line would then be:

if String.Compare(sFirstItem, sSecondItem, True) =0 then

As before, the Trim function is still available. For those who don’t know about it, let’s say, when someone enters their password, they inadvertently typed in a space either before, or at the end of the password. Therefore, when the login occurred, technically, the password would not match, since the original password did not have the space in it. To get around this in Classic ASP, you would use the Trim Function like this:

Response.Write (Trim(sPassword))

In ASP.Net, the format is :

response.Write (sPassword.Trim())

This would take what was originally typed in as ” ThisisMyPassword ” and make it “ThisisMyPassword”Along with the Trim function, there is TrimStart and TrimEnd, which specifically trim from the – you guessed it – start and end of the string. Each of the Trim functions also accept a character array as a parameter in order to remove characters other than basic white space from the strings.

Also, in Classic ASP days, we had the Replace Function. It’s still here in ASP.Net, but with a different formatting, as usual. Instead of using:

sItem = Replace(sItem, “CharacterToBeReplaced”, “ReplacementCharacter”)

We now use:

sItem = sItem.Replace(“CharacterToBeReplaced”, “ReplacementCharacter”)

Along with the Replace Function, there is now, also an Insert Function:

sItem = sItem.Insert(10, “Wow – this is really cool!”)

Here, we insert the string “Wow – this is really cool!”, 10 characters into the string.Again, as before, we had, and still have the Split function, but now it’s formatted a little differently. The Split function takes a string and ’splits’ the string into sections, at certain intervals, based on a common separator between those characters, and puts the sections into an array. As a default, it defaults at any white space being the separator. So, if you had a string that was separated by a space or tab, etc, and just use :

arrNewSplit = sString.Split()

If it was a comma-delimited string, you would use:

arrNewSplit = sString.Split(“,”)

This pretty well wraps up what these tutorials are going to cover. By no means is this all ASP.Net does with strings, but what has been mentioned in the last two tutorials is, what we believe are some of the most common useages and the most helpful points of the String Class.

Chars  : Belirlenmiş bir karakterin yerine karakter ekler.
Length : Stringdeki karakter sayısını verir.
Compare : Belirlenmiş iki string nesnesini karakter sayılarına göre karşılaştırır.
Sonuç eşit ise “0”, büyükse “+1”, küçükse”-1” değerlerini döndürür.
CompareTo :  Belirlenen iki stringi alfabetik sıraya göre karşılaştır. Sonuç eşit ise “0”,
eşit değil ise “-1” değeri geri döndürür.
Concat : Stringi bir veya birden fazla string ile birleştirir. 
Contains  : String içerisinde belirlenmiş başka string nesnelerinin bulunup
bulun madığını kontrol eder.
Copy : Belirlenmiş bir string karakterlerini kullanarak yeni bir örnek string
oluşturur.
EndsWith :  Stringin sonunda belirli bir string örneğinin olup olmadığına karar verir.
Equals :  İki string nesnesinin aynı değerlere sahip olup olmadığı kontrol eder. True
veya false değerleri geri döndürür.
Format  : Stringi bilgiyi belli bir biçime dönüştürür.
GetEnumerator :  String içerisinde tekrar eden bir nesne bulur.
GetHashCode : Stringdeki bozuk kodu bulur.
GetType : Örneğin tipini verir.
GetTypeCode :  Stringin  Type code (Tür kodunu) çağırır.
IndexOf  : Stringin içindeki dizenin başlangıç noktasını bulur.
IndexOfAny  : Stringdeki herhangi bir karakterin başlangıç noktasını bulur.
Insert  : String içerisine karakter ekler.
IsNullOrEmpty : Stringin boş olup olmadığını gösterir.
LastIndexOf   : Bir karakter veya karakter grubunun stringin içinde bulunduğu pozisyonu
sayısal olarak ifade eder. (Eğer karakter veya karakter grubu string
içerisinde birden fazla ise en sondaki karakter veya karakter grubunun
sayısal olarak bulunduğu yeri belirtir.)
PadLeft : Stringin solundan başlayarak stringin boyutu verilen değere eşit olana
kadar istenilen karakter eklenir.
PadRight : Stringin sağından başlayarak stringin boyutu verilen değere eşit olana
kadar istenilen karakter eklenir.
ReferenceEquals Belirlenmiş nesne örneklerinin referans türle aynı olup olmadığına karar
verir.
Remove  : String içerisinde belirli sayıda karakter siler.
Replace :Stringin istediğimiz karakterlerini değiştirmek için kullanılır.
StartsWith : Belirlenen bir dizenin stringin başlangıcı olup olmadığını bulur. Boolean
tipte bir değer döndürür.
Substring  Stringde belirtilen bir karakterden başlayarak sabit sayıda karakter
döndürür.
ToCharArray :  Stringi dizi karakterlerine çevirir.
ToLower  :Stringdeki harfleri küçük harfe dönüştürür.
ToString : Bilgileri string türüne dönüştürür.
ToUpper  : Stringdeki harfleri büyük harfe dönüştürür.
Trim  : Stringin başında ve sonundaki boşlukları veya belirtilen karakterleri
kaldırır.
TrimEnd  : Stringin sonundaki boşlukları veya belirtilen karakterleri kaldırır.
TrimStart  : Stringin başındaki boşlukları veya belirtilen karakterleri kaldırır.

*—–KULLANIMI—-*

1.  a.Length = 1. stringin karakter uzunluğunu verir. Uzunluk bulunurken boşluklar
dâhil edilir.
2.  b.Chars(1) = 2  . stringin 1. elemanını ekrana yazdırır. Dikkat edilecek husus
stringin ilk karakteri  0. elemanıdır.
3.  a.CompareTo(b) = 1  . string ile 2. stringi karşılaştırır. İki string eşit -1 değeri
döndürür.
4.  String.Concat(a, b) = 1 . stringin sonuna 2. stringi ekler. 1. stringin sonunda
veya 2. stringin başında boşluk olmadığından stringler birleştirildiğinde arada
boşluk olmaz.
5.  a.Contains(”eslek”) = 1 .  string içerisinde “eslek” kelimesi olduğundan true
değeri döndürür.
6.  String.Copy(a) = 1. stringin kopyasını oluşturur.
7.  a.IndexOf(”düstri”) = “dustri”  stringinin 1. stringin kaçıncı karakterinden
itibaren başladığını gösterir. stringin ilk elemanı 0. karakterdir.
8.  b.Insert(3, “v”) = 2.  stringin 3. karakterine v harfini ekler.
9.  String.IsNullOrEmpty(b) = 2.  Stringin boş olup olmadığını kontrol eder. Boş
olmadığı için False değeri döndürür.
10.  a.LastIndexOf(”d”) = d harfinin 1. stringin kaçıncı karakteri olduğunu bulur.
11.  a.PadLeft(30, “?”) = 1 . stringin sol tarafına toplam uzunluk 30 karakter olana
kadar “?” işareti ekler.
12.  b.PadRight(15, “*”) = 2  .  stringin sağ tarafına toplam uzunluğu 15 karakter
olana kadar “*” işareti ekler.
13.  a.Remove(3, 5) = 1 . stringin 3. karakterinden başlayarak 5 karakter siler.
14.  b.ToUpper = 2 . stringin bütün karakterlerini büyük harfe çevirir.
15.  a.ToLower = 1 . stringin bütün karakterlerini küçük harfe çevirir.
16.  a.Trim(”En”) = 1 . stringin başında veya sonunda En kelimesi varsa bulup siler.
17.  a.Replace(”Meslek”, “Teknik”) = 1  . string içerisinde “Meslek” kelimesini
arayıp bulduğunda “Teknik” kelimesi ile yer değiştirir.

Php uses stripos

$pos3 = stripos($pageURL , ‘-q-’) + 3 ;

Does that headline look like a bunch of cussing to you? I was hoping it would be offensive.

I’m also looking forward to see how it’s covered by the tech aggregators like Digg and Reddit. And I want to see if perhaps people land here as the result of searching for a bunch of punctuation.

Mostly I wanted to talk about JavaScript types, and how you can convert from boolean to numeric and vice versa.

This is going to be a pretty freeform discussion. If you get bored jump right to the end–there’s a trick there that’s pretty useful.

Big Mistake. Big, Big Mistake

Douglas Crockford has often mentioned that the dual usage for the plus symbol is a mistake in JavaScript. He’s right. It’s used both for numeric addition and for string concatenation. This trips programmers up all the time and there’s just no excuse for it. No upside. Another symbol should have been used for string concatenation.

The common solution to this is to wait until you get tripped up, find which term is being mistaken for a string, and then use one of the functions that JavaScript provides that converts strings to numbers. I prefer to use yet another usage of the plus symbol to do that work. I use the unary version of plus.

For example:

num = 1 + +"2"; //num is assigned the value 3

See the space between the plus signs? Yeah, that’s critical. You don’t want to mistake those two pluses for the symbol ++, the increment operator.

A unary minus works too, if you happen to want the negated version.

num = 1 - -"2"; //num is assigned the value 3, again

There’s another cool use for the plus sign. It’ll turn true and false into numbers.

num=+true; // num is 1
num=+false; //num is 0
num=-true; // num is -1
num=-false; //num is 0

So we turn true and false into 1 and 0 with unary plus. How do we turn 1 and 0 into true and false? One way is with the bang (exclamation point). In this case, we actually use a double-bang or “bang bang.” (Google “bang bang cher” and find out that long before William Hung banged, Cher banged.)

bool = !!1; //bool is true
bool = !!0; //bool is false

The first bang casts from the number to a Boolean, and the second undoes the logical not that was performed by the first bang.

You still following? How about a curve ball?

num = 1 + ~~"2"; //what the hell is that?

Welcome to the tilde. The result is 3 again, but what’s with the squiggles? The squiggle, of course, is the tilde operator. JavaScript programmers learn it and then promptly forget about it. But it plays a part in one of my favorite JavaScript tricks. We’ll see that right at the end. For now, let’s look at what it does to some values.

console.log(~-2); //1
console.log(~-1); //0
console.log(~0); //-1
console.log(~1); //-2
console.log(~2); //-3
console.log(~true); //-2
console.log(~false); //-1

As you can see, ~ is doing -(N+1). For fun, let’s throw a unary minus into the mix.

console.log(-~-2); //-1
console.log(-~-1); //0
console.log(-~0); //1
console.log(-~1); //2
console.log(-~2); //3
console.log(-~true); //2
console.log(-~false); //1

So -~N is the same as N+1.

Now let’s look at the bang symbol along with the tilde.

console.log(!-2); //false
console.log(!-1); //false
console.log(!0); //true
console.log(!1); //false
console.log(!2); //false
console.log(!true); //false
console.log(!false); //true

And for fun, let’s put the bang and the tilde together…

console.log(!~-2); //false
console.log(!~-1); //true
console.log(!~0); //false
console.log(!~1); //false
console.log(!~2); //false
console.log(!~true); //false
console.log(!~false); //false

Now that’s interesting. Only the value -1 makes it out alive with a true value. And come to think of it, there’s something special about -1. It’s a common sentinel value returned by functions that return indexes (JavaScript’s indexOf() is a great example, but you may have your own functions that return -1 as a sentinel value).

WTF?

What am I talking about? Suppose you want to know where the letter “s” is in a string. Well, you either get a number back that tells you where it is, or you get a -1 back telling you, hey buddy, no “s” in this string. So you end up with code like…

if (index>=0) {
 //found it
} else {
 //didn't
}

or

if (index>-1) {
 //found it
} else {
 //didn't
}

or

if (index!=-1) {
 //found it
} else {
 //didn't
}

But with what we now know about tilde, we can just do this…

if (!~index) {
 //found it
} else {
 //didn't
}

Or, finally, we can turn the logic around and do this…

if (~index) {
 //didn't find it
} else {
 //did
}

Credit

I’ve seen this trick a few times before. Add a comment to this post if you can help me find other places this has been mentioned.

Web Reflections

This a simple way to find MP3 songs by Google Search. You need no such extra tools and application and membership. Simply googling with certain keyword.

This is the way:
1. Open Google.
2. Type this query in the search box ?intitle:index.of? mp3 [artist] [title]
Change [artist] with artist/band name and [title] with the songs title you look for.

Examples:

?intitle:index.of? mp3 coldplay
?intitle:index.of? mp3 “simple plan”
?intitle:index.of? mp3 “simple plan” untitled
?intitle:index.of? mp3 “welcome to my life”

Emule en Google… o algo por el estilo. Lo he visto por ahí y no sé seguro por dónde nos van a llegar los tiros, pero de momento un ‘truco’ o ‘way’ para utilizar Google más eficazmente a la hora de realizar búsquedas de canciones.

Es cierto que si introducimos el nombre de un artista o canción en la barra de búsqueda de Google nos devuelve millones de resultados, letras, páginas publicitarias, webs oficiales, en fin, una cantidad asombrosa de resultados entre las cuales encontrar el archivo de audio o mp3 que buscamos es casi imposible. Ahora bien, hay otra forma. Miki nos habla de cómo encontrar música en internet pero anteriormente ya había explicado cómo podíamos jugar con Google para encontrar los archivos de música que queremos.

Prosigo; introducimos en nuestra barra de Google la siguiente línea:

intitle:”index.of” (mp3|mp4|avi) titulo.de.la.cancion.separado.con.puntos

Nos aparecerá una lista de sitios bastante más reducida y en la que nos muestra los sitios que tienen ese archivo bien en mp3, mp4 o avi que viene a ser lo que nos interesa. Bien, llegados a este punto puede que nos interese descargar el archivo de música en vez de escucharlo a través de los reproductores de los navegadores. Yo por ejemplo, para eso utilizo DownloadHelper para el Mozilla Firefox que es el que uso. Con esta herramienta únicamente tenemos que seleccionar el archivo que queremos de todos los que identifica como multimedia que pueda haber en la página que estamos viendo y lo guarda en nuestro equipo a golpe de un par de clicks. Y así, sucesivamente.