a === b -> identical(a, b)

runtime/lib/string_base.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * [_StringBase] contains common methods used by concrete String
  * implementations, e.g., _OneByteString.
  */
 class _StringBase {
 
@@ skipping 25 matching lines @@
   static String _createFromCodePoints(List<int> codePoints)
       native "StringBase_createFromCodePoints";
 
   String operator [](int index) native "String_charAt";
 
   int charCodeAt(int index) native "String_charCodeAt";
 
   int get length native "String_getLength";
 
   bool get isEmpty {
-    return this.length === 0;
+    return this.length == 0;
   }
 
   String concat(String other) native "String_concat";
 
   String toString() {
     return this;
   }
 
   bool operator ==(Object other) {
     if (this === other) {
       return true;
     }
     if ((other is !String) ||
         (this.length != other.length)) {
       // TODO(5413632): Compare hash codes when both are present.
       return false;
     }
-    return this.compareTo(other) === 0;
+    return this.compareTo(other) == 0;
   }
 
   int compareTo(String other) {
     int thisLength = this.length;
     int otherLength = other.length;
     int len = (thisLength < otherLength) ? thisLength : otherLength;
     for (int i = 0; i < len; i++) {
       int thisCodePoint = this.charCodeAt(i);
       int otherCodePoint = other.charCodeAt(i);
       if (thisCodePoint < otherCodePoint) {
@@ skipping 59 matching lines @@
     }
     for (int index = start; index >= 0; index--) {
       if (_substringMatches(index, other)) {
         return index;
       }
     }
     return -1;
   }
 
   String substring(int startIndex, [int endIndex]) {
-    if (endIndex === null) endIndex = this.length;
+    if (endIndex == null) endIndex = this.length;
 
     if ((startIndex < 0) || (startIndex > this.length)) {
       throw new RangeError.value(startIndex);
     }
     if ((endIndex < 0) || (endIndex > this.length)) {
       throw new RangeError.value(endIndex);
     }
     if (startIndex > endIndex) {
       throw new RangeError.value(startIndex);
     }
@@ skipping 156 matching lines @@
     return result;
   }
 
   String toUpperCase() native "String_toUpperCase";
 
   String toLowerCase() native "String_toLowerCase";
 
   // Implementations of Strings methods follow below.
   static String join(List<String> strings, String separator) {
     final int length = strings.length;
-    if (length === 0) {
+    if (length == 0) {
       return "";
     }
 
     List stringsList = strings;
     if (separator.length != 0) {
       stringsList = new List(2 * length - 1);
       stringsList[0] = strings[0];
       int j = 1;
       for (int i = 1; i < length; i++) {
         stringsList[j++] = separator;
@@ skipping 26 matching lines @@
   factory _OneByteString._uninstantiable() {
     throw new UnsupportedError(
         "_OneByteString can only be allocated by the VM");
   }
 
   // Checks for one-byte whitespaces only.
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
   // whitespaces for one byte strings.
   bool _isWhitespace(int codePoint) {
     return
-      (codePoint === 32) || // Space.
+      (codePoint == 32) || // Space.
       ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 
 }
 
 
 class _TwoByteString extends _StringBase implements String {
   factory _TwoByteString._uninstantiable() {
     throw new UnsupportedError(
         "_TwoByteString can only be allocated by the VM");
   }
 
   // Checks for one-byte whitespaces only.
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
   // whitespaces. Add checking for multi-byte whitespace codepoints.
   bool _isWhitespace(int codePoint) {
     return
-      (codePoint === 32) || // Space.
+      (codePoint == 32) || // Space.
       ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 }
 
 
 class _FourByteString extends _StringBase implements String {
   factory _FourByteString._uninstantiable() {
     throw new UnsupportedError(
         "_FourByteString can only be allocated by the VM");
   }
 
   // Checks for one-byte whitespaces only.
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
   // whitespaces. Add checking for multi-byte whitespace codepoints.
   bool _isWhitespace(int codePoint) {
     return
-      (codePoint === 32) || // Space.
+      (codePoint == 32) || // Space.
       ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 }
 
 
 class _ExternalOneByteString extends _StringBase implements String {
   factory _ExternalOneByteString._uninstantiable() {
     throw new UnsupportedError(
         "_ExternalOneByteString can only be allocated by the VM");
   }
 
   // Checks for one-byte whitespaces only.
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
   // whitespaces for one byte strings.
   bool _isWhitespace(int codePoint) {
     return
-      (codePoint === 32) || // Space.
+      (codePoint == 32) || // Space.
       ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 }
 
 
 class _ExternalTwoByteString extends _StringBase implements String {
   factory ExternalTwoByteString._uninstantiable() {
     throw new UnsupportedError(
         "_ExternalTwoByteString can only be allocated by the VM");
   }
 
   // Checks for one-byte whitespaces only.
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
   // whitespaces. Add checking for multi-byte whitespace codepoints.
   bool _isWhitespace(int codePoint) {
     return
-      (codePoint === 32) || // Space.
+      (codePoint == 32) || // Space.
       ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 }
 
 
 class _ExternalFourByteString extends _StringBase implements String {
   factory _ExternalFourByteString._uninstantiable() {
     throw new UnsupportedError(
         "ExternalFourByteString can only be allocated by the VM");
   }
 
   // Checks for one-byte whitespaces only.
   // TODO(srdjan): Investigate if 0x85 (NEL) and 0xA0 (NBSP) are valid
   // whitespaces. Add checking for multi-byte whitespace codepoints.
   bool _isWhitespace(int codePoint) {
     return
-      (codePoint === 32) || // Space.
+      (codePoint == 32) || // Space.
       ((9 <= codePoint) && (codePoint <= 13)); // CR, LF, TAB, etc.
   }
 }
 
 
 class _StringMatch implements Match {
   const _StringMatch(int this.start,
                      String this.str,
                      String this.pattern);
 
@@ skipping 13 matching lines @@
     for (int g in groups) {
       result.add(group(g));
     }
     return result;
   }
 
   final int start;
   final String str;
   final String pattern;
 }