How to use between method of are class

...39        }40        return $reason;41    }42    /**43     * A memoization for when two fragments are compared "between" each other for44     * conflicts. Two fragments may be compared many times, so memoizing this can45     * dramatically improve the performance of this validator.46     * @var PairSet47     */48    private $comparedFragmentPairs;49    /**50     * A cache for the "field map" and list of fragment names found in any given51     * selection set. Selection sets may be asked for this information multiple52     * times, so this improves the performance of this validator.53     *54     * @var \SplObjectStorage55     */56    private $cachedFieldsAndFragmentNames;57    public function getVisitor(ValidationContext $context)58    {59        $this->comparedFragmentPairs = new PairSet();60        $this->cachedFieldsAndFragmentNames = new \SplObjectStorage();61        return [62            NodeKind::SELECTION_SET => function(SelectionSetNode $selectionSet) use ($context) {63                $conflicts = $this->findConflictsWithinSelectionSet(64                    $context,65                    $context->getParentType(),66                    $selectionSet67                );68                foreach ($conflicts as $conflict) {69                    $responseName = $conflict[0][0];70                    $reason = $conflict[0][1];71                    $fields1 = $conflict[1];72                    $fields2 = $conflict[2];73                    $context->reportError(new Error(74                        self::fieldsConflictMessage($responseName, $reason),75                        array_merge($fields1, $fields2)76                    ));77                }78            }79        ];80    }81    /**82     * Algorithm:83     *84     * Conflicts occur when two fields exist in a query which will produce the same85     * response name, but represent differing values, thus creating a conflict.86     * The algorithm below finds all conflicts via making a series of comparisons87     * between fields. In order to compare as few fields as possible, this makes88     * a series of comparisons "within" sets of fields and "between" sets of fields.89     *90     * Given any selection set, a collection produces both a set of fields by91     * also including all inline fragments, as well as a list of fragments92     * referenced by fragment spreads.93     *94     * A) Each selection set represented in the document first compares "within" its95     * collected set of fields, finding any conflicts between every pair of96     * overlapping fields.97     * Note: This is the *only time* that a the fields "within" a set are compared98     * to each other. After this only fields "between" sets are compared.99     *100     * B) Also, if any fragment is referenced in a selection set, then a101     * comparison is made "between" the original set of fields and the102     * referenced fragment.103     *104     * C) Also, if multiple fragments are referenced, then comparisons105     * are made "between" each referenced fragment.106     *107     * D) When comparing "between" a set of fields and a referenced fragment, first108     * a comparison is made between each field in the original set of fields and109     * each field in the the referenced set of fields.110     *111     * E) Also, if any fragment is referenced in the referenced selection set,112     * then a comparison is made "between" the original set of fields and the113     * referenced fragment (recursively referring to step D).114     *115     * F) When comparing "between" two fragments, first a comparison is made between116     * each field in the first referenced set of fields and each field in the the117     * second referenced set of fields.118     *119     * G) Also, any fragments referenced by the first must be compared to the120     * second, and any fragments referenced by the second must be compared to the121     * first (recursively referring to step F).122     *123     * H) When comparing two fields, if both have selection sets, then a comparison124     * is made "between" both selection sets, first comparing the set of fields in125     * the first selection set with the set of fields in the second.126     *127     * I) Also, if any fragment is referenced in either selection set, then a128     * comparison is made "between" the other set of fields and the129     * referenced fragment.130     *131     * J) Also, if two fragments are referenced in both selection sets, then a132     * comparison is made "between" the two fragments.133     *134     */135    /**136     * Find all conflicts found "within" a selection set, including those found137     * via spreading in fragments. Called when visiting each SelectionSet in the138     * GraphQL Document.139     *140     * @param ValidationContext $context141     * @param CompositeType $parentType142     * @param SelectionSetNode $selectionSet143     * @return array144     */145    private function findConflictsWithinSelectionSet(146        ValidationContext $context,147        $parentType,148        SelectionSetNode $selectionSet)149    {150        list($fieldMap, $fragmentNames) = $this->getFieldsAndFragmentNames(151            $context,152            $parentType,153            $selectionSet154        );155        $conflicts = [];156        // (A) Find find all conflicts "within" the fields of this selection set.157        // Note: this is the *only place* `collectConflictsWithin` is called.158        $this->collectConflictsWithin(159            $context,160            $conflicts,161            $fieldMap162        );163        $fragmentNamesLength = count($fragmentNames);164        if ($fragmentNamesLength !== 0) {165            // (B) Then collect conflicts between these fields and those represented by166            // each spread fragment name found.167            $comparedFragments = [];168            for ($i = 0; $i < $fragmentNamesLength; $i++) {169                $this->collectConflictsBetweenFieldsAndFragment(170                    $context,171                    $conflicts,172                    $comparedFragments,173                    false,174                    $fieldMap,175                    $fragmentNames[$i]176                );177                // (C) Then compare this fragment with all other fragments found in this178                // selection set to collect conflicts between fragments spread together.179                // This compares each item in the list of fragment names to every other item180                // in that same list (except for itself).181                for ($j = $i + 1; $j < $fragmentNamesLength; $j++) {182                    $this->collectConflictsBetweenFragments(183                        $context,184                        $conflicts,185                        false,186                        $fragmentNames[$i],187                        $fragmentNames[$j]188                    );189                }190            }191        }192        return $conflicts;193    }194    /**195     * Collect all conflicts found between a set of fields and a fragment reference196     * including via spreading in any nested fragments.197     *198     * @param ValidationContext $context199     * @param array $conflicts200     * @param array $comparedFragments201     * @param bool $areMutuallyExclusive202     * @param array $fieldMap203     * @param string $fragmentName204     */205    private function collectConflictsBetweenFieldsAndFragment(206        ValidationContext $context,207        array &$conflicts,208        array &$comparedFragments,209        $areMutuallyExclusive,210        array $fieldMap,211        $fragmentName212    ) {213        if (isset($comparedFragments[$fragmentName])) {214            return;215        }216        $comparedFragments[$fragmentName] = true;217        $fragment = $context->getFragment($fragmentName);218        if (!$fragment) {219            return;220        }221        list($fieldMap2, $fragmentNames2) = $this->getReferencedFieldsAndFragmentNames(222            $context,223            $fragment224        );225        if ($fieldMap === $fieldMap2) {226            return;227        }228        // (D) First collect any conflicts between the provided collection of fields229        // and the collection of fields represented by the given fragment.230        $this->collectConflictsBetween(231          $context,232          $conflicts,233          $areMutuallyExclusive,234          $fieldMap,235          $fieldMap2236        );237        // (E) Then collect any conflicts between the provided collection of fields238        // and any fragment names found in the given fragment.239        $fragmentNames2Length = count($fragmentNames2);240        for ($i = 0; $i < $fragmentNames2Length; $i++) {241            $this->collectConflictsBetweenFieldsAndFragment(242                $context,243                $conflicts,244                $comparedFragments,245                $areMutuallyExclusive,246                $fieldMap,247                $fragmentNames2[$i]248            );249        }250    }251    /**252     * Collect all conflicts found between two fragments, including via spreading in253     * any nested fragments.254     *255     * @param ValidationContext $context256     * @param array $conflicts257     * @param bool $areMutuallyExclusive258     * @param string $fragmentName1259     * @param string $fragmentName2260     */261    private function collectConflictsBetweenFragments(262        ValidationContext $context,263        array &$conflicts,264        $areMutuallyExclusive,265        $fragmentName1,266        $fragmentName2267    ) {268        // No need to compare a fragment to itself.269        if ($fragmentName1 === $fragmentName2) {270            return;271        }272        // Memoize so two fragments are not compared for conflicts more than once.273        if (274            $this->comparedFragmentPairs->has(275                $fragmentName1,276                $fragmentName2,277                $areMutuallyExclusive278            )279        ) {280            return;281        }282        $this->comparedFragmentPairs->add(283            $fragmentName1,284            $fragmentName2,285            $areMutuallyExclusive286        );287        $fragment1 = $context->getFragment($fragmentName1);288        $fragment2 = $context->getFragment($fragmentName2);289        if (!$fragment1 || !$fragment2) {290            return;291        }292        list($fieldMap1, $fragmentNames1) = $this->getReferencedFieldsAndFragmentNames(293            $context,294            $fragment1295        );296        list($fieldMap2, $fragmentNames2) = $this->getReferencedFieldsAndFragmentNames(297            $context,298            $fragment2299        );300        // (F) First, collect all conflicts between these two collections of fields301        // (not including any nested fragments).302        $this->collectConflictsBetween(303          $context,304          $conflicts,305          $areMutuallyExclusive,306          $fieldMap1,307          $fieldMap2308        );309        // (G) Then collect conflicts between the first fragment and any nested310        // fragments spread in the second fragment.311        $fragmentNames2Length = count($fragmentNames2);312        for ($j = 0; $j < $fragmentNames2Length; $j++) {313            $this->collectConflictsBetweenFragments(314                $context,315                $conflicts,316                $areMutuallyExclusive,317                $fragmentName1,318                $fragmentNames2[$j]319            );320        }321        // (G) Then collect conflicts between the second fragment and any nested322        // fragments spread in the first fragment.323        $fragmentNames1Length = count($fragmentNames1);324        for ($i = 0; $i < $fragmentNames1Length; $i++) {325            $this->collectConflictsBetweenFragments(326                $context,327                $conflicts,328                $areMutuallyExclusive,329                $fragmentNames1[$i],330                $fragmentName2331            );332        }333    }334    /**335     * Find all conflicts found between two selection sets, including those found336     * via spreading in fragments. Called when determining if conflicts exist337     * between the sub-fields of two overlapping fields.338     *339     * @param ValidationContext $context340     * @param bool $areMutuallyExclusive341     * @param CompositeType $parentType1342     * @param $selectionSet1343     * @param CompositeType $parentType2344     * @param $selectionSet2345     * @return array346     */347    private function findConflictsBetweenSubSelectionSets(348        ValidationContext $context,349        $areMutuallyExclusive,350        $parentType1,351        SelectionSetNode $selectionSet1,352        $parentType2,353        SelectionSetNode $selectionSet2354    ) {355        $conflicts = [];356        list($fieldMap1, $fragmentNames1) = $this->getFieldsAndFragmentNames(357            $context,358            $parentType1,359            $selectionSet1360        );361        list($fieldMap2, $fragmentNames2) = $this->getFieldsAndFragmentNames(362            $context,363            $parentType2,364            $selectionSet2365        );366        // (H) First, collect all conflicts between these two collections of field.367        $this->collectConflictsBetween(368            $context,369            $conflicts,370            $areMutuallyExclusive,371            $fieldMap1,372            $fieldMap2373        );374        // (I) Then collect conflicts between the first collection of fields and375        // those referenced by each fragment name associated with the second.376        $fragmentNames2Length = count($fragmentNames2);377        if ($fragmentNames2Length !== 0) {378            $comparedFragments = [];379            for ($j = 0; $j < $fragmentNames2Length; $j++) {380                $this->collectConflictsBetweenFieldsAndFragment(381                    $context,382                    $conflicts,383                    $comparedFragments,384                    $areMutuallyExclusive,385                    $fieldMap1,386                    $fragmentNames2[$j]387                );388            }389        }390        // (I) Then collect conflicts between the second collection of fields and391        // those referenced by each fragment name associated with the first.392        $fragmentNames1Length = count($fragmentNames1);393        if ($fragmentNames1Length !== 0) {394            $comparedFragments = [];395            for ($i = 0; $i < $fragmentNames1Length; $i++) {396                $this->collectConflictsBetweenFieldsAndFragment(397                    $context,398                    $conflicts,399                    $comparedFragments,400                    $areMutuallyExclusive,401                    $fieldMap2,402                    $fragmentNames1[$i]403                );404            }405        }406        // (J) Also collect conflicts between any fragment names by the first and407        // fragment names by the second. This compares each item in the first set of408        // names to each item in the second set of names.409        for ($i = 0; $i < $fragmentNames1Length; $i++) {410            for ($j = 0; $j < $fragmentNames2Length; $j++) {411                $this->collectConflictsBetweenFragments(412                    $context,413                    $conflicts,414                    $areMutuallyExclusive,415                    $fragmentNames1[$i],416                    $fragmentNames2[$j]417                );418            }419        }420        return $conflicts;421    }422    /**423     * Collect all Conflicts "within" one collection of fields.424     *425     * @param ValidationContext $context426     * @param array $conflicts427     * @param array $fieldMap428     */429    private function collectConflictsWithin(430        ValidationContext $context,431        array &$conflicts,432        array $fieldMap433    )434    {435        // A field map is a keyed collection, where each key represents a response436        // name and the value at that key is a list of all fields which provide that437        // response name. For every response name, if there are multiple fields, they438        // must be compared to find a potential conflict.439        foreach ($fieldMap as $responseName => $fields) {440            // This compares every field in the list to every other field in this list441            // (except to itself). If the list only has one item, nothing needs to442            // be compared.443            $fieldsLength = count($fields);444            if ($fieldsLength > 1) {445                for ($i = 0; $i < $fieldsLength; $i++) {446                    for ($j = $i + 1; $j < $fieldsLength; $j++) {447                        $conflict = $this->findConflict(448                            $context,449                            false, // within one collection is never mutually exclusive450                            $responseName,451                            $fields[$i],452                            $fields[$j]453                        );454                        if ($conflict) {455                            $conflicts[] = $conflict;456                        }457                    }458                }459            }460        }461    }462    /**463     * Collect all Conflicts between two collections of fields. This is similar to,464     * but different from the `collectConflictsWithin` function above. This check465     * assumes that `collectConflictsWithin` has already been called on each466     * provided collection of fields. This is true because this validator traverses467     * each individual selection set.468     *469     * @param ValidationContext $context470     * @param array $conflicts471     * @param bool $parentFieldsAreMutuallyExclusive472     * @param array $fieldMap1473     * @param array $fieldMap2474     */475    private function collectConflictsBetween(476        ValidationContext $context,477        array &$conflicts,478        $parentFieldsAreMutuallyExclusive,479        array $fieldMap1,480        array $fieldMap2481    ) {482        // A field map is a keyed collection, where each key represents a response483        // name and the value at that key is a list of all fields which provide that484        // response name. For any response name which appears in both provided field485        // maps, each field from the first field map must be compared to every field486        // in the second field map to find potential conflicts.487        foreach ($fieldMap1 as $responseName => $fields1) {488            if (isset($fieldMap2[$responseName])) {489                $fields2 = $fieldMap2[$responseName];490                $fields1Length = count($fields1);491                $fields2Length = count($fields2);492                for ($i = 0; $i < $fields1Length; $i++) {493                    for ($j = 0; $j < $fields2Length; $j++) {494                        $conflict = $this->findConflict(495                            $context,496                            $parentFieldsAreMutuallyExclusive,497                            $responseName,498                            $fields1[$i],499                            $fields2[$j]500                        );501                        if ($conflict) {502                            $conflicts[] = $conflict;503                        }504                    }505                }506            }507        }508    }509    /**510     * Determines if there is a conflict between two particular fields, including511     * comparing their sub-fields.512     *513     * @param ValidationContext $context514     * @param bool $parentFieldsAreMutuallyExclusive515     * @param string $responseName516     * @param array $field1517     * @param array $field2518     * @return array|null519     */520    private function findConflict(521        ValidationContext $context,522        $parentFieldsAreMutuallyExclusive,523        $responseName,524        array $field1,525        array $field2526    )527    {528        list($parentType1, $ast1, $def1) = $field1;529        list($parentType2, $ast2, $def2) = $field2;530        // If it is known that two fields could not possibly apply at the same531        // time, due to the parent types, then it is safe to permit them to diverge532        // in aliased field or arguments used as they will not present any ambiguity533        // by differing.534        // It is known that two parent types could never overlap if they are535        // different Object types. Interface or Union types might overlap - if not536        // in the current state of the schema, then perhaps in some future version,537        // thus may not safely diverge.538        $areMutuallyExclusive =539            $parentFieldsAreMutuallyExclusive ||540            $parentType1 !== $parentType2 &&541            $parentType1 instanceof ObjectType &&542            $parentType2 instanceof ObjectType;543        // The return type for each field.544        $type1 = $def1 ? $def1->getType() : null;545        $type2 = $def2 ? $def2->getType() : null;546        if (!$areMutuallyExclusive) {547            // Two aliases must refer to the same field.548            $name1 = $ast1->name->value;549            $name2 = $ast2->name->value;550            if ($name1 !== $name2) {551                return [552                    [$responseName, "$name1 and $name2 are different fields"],553                    [$ast1],554                    [$ast2]555                ];556            }557            if (!$this->sameArguments($ast1->arguments ?: [], $ast2->arguments ?: [])) {558                return [559                    [$responseName, 'they have differing arguments'],560                    [$ast1],561                    [$ast2]562                ];563            }564        }565        if ($type1 && $type2 && $this->doTypesConflict($type1, $type2)) {566            return [567                [$responseName, "they return conflicting types $type1 and $type2"],568                [$ast1],569                [$ast2]570            ];571        }572        // Collect and compare sub-fields. Use the same "visited fragment names" list573        // for both collections so fields in a fragment reference are never574        // compared to themselves.575        $selectionSet1 = $ast1->selectionSet;576        $selectionSet2 = $ast2->selectionSet;577        if ($selectionSet1 && $selectionSet2) {578            $conflicts = $this->findConflictsBetweenSubSelectionSets(579                $context,580                $areMutuallyExclusive,581                Type::getNamedType($type1),582                $selectionSet1,583                Type::getNamedType($type2),584                $selectionSet2585            );586            return $this->subfieldConflicts(587                $conflicts,588                $responseName,589                $ast1,590                $ast2591            );592        }593        return null;594    }595    /**596     * @param ArgumentNode[] $arguments1597     * @param ArgumentNode[] $arguments2598     *599     * @return bool600     */601    private function sameArguments($arguments1, $arguments2)602    {603        if (count($arguments1) !== count($arguments2)) {604            return false;605        }606        foreach ($arguments1 as $argument1) {607            $argument2 = null;608            foreach ($arguments2 as $argument) {609                if ($argument->name->value === $argument1->name->value) {610                    $argument2 = $argument;611                    break;612                }613            }614            if (!$argument2) {615                return false;616            }617            if (!$this->sameValue($argument1->value, $argument2->value)) {618                return false;619            }620        }621        return true;622    }623    /**624     * @param Node $value1625     * @param Node $value2626     * @return bool627     */628    private function sameValue(Node $value1, Node $value2)629    {630        return (!$value1 && !$value2) || (Printer::doPrint($value1) === Printer::doPrint($value2));631    }632    /**633     * Two types conflict if both types could not apply to a value simultaneously.634     * Composite types are ignored as their individual field types will be compared635     * later recursively. However List and Non-Null types must match.636     *637     * @param OutputType $type1638     * @param OutputType $type2639     * @return bool640     */641    private function doTypesConflict(OutputType $type1, OutputType $type2)642    {643        if ($type1 instanceof ListOfType) {644            return $type2 instanceof ListOfType ?645                $this->doTypesConflict($type1->getWrappedType(), $type2->getWrappedType()) :646                true;647        }648        if ($type2 instanceof ListOfType) {649            return $type1 instanceof ListOfType ?650                $this->doTypesConflict($type1->getWrappedType(), $type2->getWrappedType()) :651                true;652        }653        if ($type1 instanceof NonNull) {654            return $type2 instanceof NonNull ?655                $this->doTypesConflict($type1->getWrappedType(), $type2->getWrappedType()) :656                true;657        }658        if ($type2 instanceof NonNull) {659            return $type1 instanceof NonNull ?660                $this->doTypesConflict($type1->getWrappedType(), $type2->getWrappedType()) :661                true;662        }663        if (Type::isLeafType($type1) || Type::isLeafType($type2)) {664            return $type1 !== $type2;665        }666        return false;667    }668    /**669     * Given a selection set, return the collection of fields (a mapping of response670     * name to field ASTs and definitions) as well as a list of fragment names671     * referenced via fragment spreads.672     *673     * @param ValidationContext $context674     * @param CompositeType $parentType675     * @param SelectionSetNode $selectionSet676     * @return array677     */678    private function getFieldsAndFragmentNames(679        ValidationContext $context,680        $parentType,681        SelectionSetNode $selectionSet682    ) {683        if (!isset($this->cachedFieldsAndFragmentNames[$selectionSet])) {684            $astAndDefs = [];685            $fragmentNames = [];686            $this->internalCollectFieldsAndFragmentNames(687                $context,688                $parentType,689                $selectionSet,690                $astAndDefs,691                $fragmentNames692            );693            $cached = [$astAndDefs, array_keys($fragmentNames)];694            $this->cachedFieldsAndFragmentNames[$selectionSet] = $cached;695        } else {696            $cached = $this->cachedFieldsAndFragmentNames[$selectionSet];697        }698        return $cached;699    }700    /**701     * Given a reference to a fragment, return the represented collection of fields702     * as well as a list of nested fragment names referenced via fragment spreads.703     *704     * @param ValidationContext $context705     * @param FragmentDefinitionNode $fragment706     * @return array|object707     */708    private function getReferencedFieldsAndFragmentNames(709        ValidationContext $context,710        FragmentDefinitionNode $fragment711    )712    {713        // Short-circuit building a type from the AST if possible.714        if (isset($this->cachedFieldsAndFragmentNames[$fragment->selectionSet])) {715            return $this->cachedFieldsAndFragmentNames[$fragment->selectionSet];716        }717        $fragmentType = TypeInfo::typeFromAST($context->getSchema(), $fragment->typeCondition);718        return $this->getFieldsAndFragmentNames(719            $context,720            $fragmentType,721            $fragment->selectionSet722        );723    }724    /**725     * Given a reference to a fragment, return the represented collection of fields726     * as well as a list of nested fragment names referenced via fragment spreads.727     *728     * @param ValidationContext $context729     * @param CompositeType $parentType730     * @param SelectionSetNode $selectionSet731     * @param array $astAndDefs732     * @param array $fragmentNames733     */734    private function internalCollectFieldsAndFragmentNames(735        ValidationContext $context,736        $parentType,737        SelectionSetNode $selectionSet,738        array &$astAndDefs,739        array &$fragmentNames740    )741    {742        $selectionSetLength = count($selectionSet->selections);743        for ($i = 0; $i < $selectionSetLength; $i++) {744            $selection = $selectionSet->selections[$i];745            switch (true) {746                case $selection instanceof FieldNode:747                    $fieldName = $selection->name->value;748                    $fieldDef = null;749                    if ($parentType instanceof ObjectType ||750                        $parentType instanceof InterfaceType) {751                        $tmp = $parentType->getFields();752                        if (isset($tmp[$fieldName])) {753                            $fieldDef = $tmp[$fieldName];754                        }755                    }756                    $responseName = $selection->alias ? $selection->alias->value : $fieldName;757                    if (!isset($astAndDefs[$responseName])) {758                        $astAndDefs[$responseName] = [];759                    }760                    $astAndDefs[$responseName][] = [$parentType, $selection, $fieldDef];761                    break;762                case $selection instanceof FragmentSpreadNode:763                    $fragmentNames[$selection->name->value] = true;764                    break;765                case $selection instanceof InlineFragmentNode:766                    $typeCondition = $selection->typeCondition;767                    $inlineFragmentType = $typeCondition768                        ? TypeInfo::typeFromAST($context->getSchema(), $typeCondition)769                        : $parentType;770                    $this->internalcollectFieldsAndFragmentNames(771                        $context,772                        $inlineFragmentType,773                        $selection->selectionSet,774                        $astAndDefs,775                        $fragmentNames776                    );777                    break;778            }779        }780    }781    /**782     * Given a series of Conflicts which occurred between two sub-fields, generate783     * a single Conflict.784     *785     * @param array $conflicts786     * @param string $responseName787     * @param FieldNode $ast1788     * @param FieldNode $ast2789     * @return array|null790     */791    private function subfieldConflicts(792        array $conflicts,793        $responseName,794        FieldNode $ast1,795        FieldNode $ast2796    )...

1class A {2    function foo() {3        if (isset($this)) {4            echo '$this is defined (';5            echo get_class($this);6            echo ")<br>";7        } else {8            echo "\$this is not defined.<br>";9        }10    }11}12class B {13    function bar() {14        A::foo();15    }16}17$a = new A();18$a->foo();19A::foo();20$b = new B();21$b->bar();22B::bar();23class A {24    function foo() {25        if (isset($this)) {26            echo '$this is defined (';27            echo get_class($this);28            echo ")<br>";29        } else {30            echo "\$this is not defined.<br>";31        }32    }33}34class B extends A {35    function bar() {36        A::foo();37        parent::foo();38        self::foo();39    }40}41$a = new A();42$a->foo();43A::foo();44$b = new B();45$b->bar();46B::bar();47class A {48    function foo() {49        if (isset($this)) {50            echo '$this is defined (';51            echo get_class($this);52            echo ")<br>";53        } else {54            echo "\$this is not defined.<br>";55        }56    }57}58class B extends A {59}60$a = new A();61$a->foo();62A::foo();63$b = new B();64$b->foo();65B::foo();66class A {67    function foo() {68        if (isset($this)) {69            echo '$this is defined (';70            echo get_class($this);71            echo ")<br>";72        } else {73            echo "\$this is not defined.<br>";74        }75    }76}77class B extends A {78    function foo() {79        parent::foo();80    }81}82$a = new A();83$a->foo();84A::foo();85$b = new B();86$b->foo();87B::foo();88class A {89    function foo() {90        if (isset($this)) {91            echo '$this is defined (';92            echo get_class($this

1class class1{2	public function __construct(){3		echo "class1";4	}5}6class class2{7	public function __construct(){8		echo "class2";9	}10}11class class3{12	public function __construct(){13		echo "class3";14	}15}16class class4{17	public function __construct(){18		echo "class4";19	}20}21class class5{22	public function __construct(){23		echo "class5";24	}25}26class class6{27	public function __construct(){28		echo "class6";29	}30}31class class7{32	public function __construct(){33		echo "class7";34	}35}36class class8{37	public function __construct(){38		echo "class8";39	}40}41class class9{42	public function __construct(){43		echo "class9";44	}45}46class class10{47	public function __construct(){48		echo "class10";49	}50}51class class11{52	public function __construct(){53		echo "class11";54	}55}56class class12{57	public function __construct(){58		echo "class12";59	}60}61class class13{62	public function __construct(){63		echo "class13";64	}65}66class class14{67	public function __construct(){68		echo "class14";69	}70}71class class15{72	public function __construct(){73		echo "class15";74	}75}76class class16{77	public function __construct(){78		echo "class16";79	}80}81class class17{82	public function __construct(){83		echo "class17";84	}85}86class class18{87	public function __construct(){88		echo "class18";89	}90}91class class19{92	public function __construct(){93		echo "class19";94	}95}96class class20{97	public function __construct(){98		echo "class20";99	}100}101class class21{102	public function __construct(){103		echo "class21";104	}105}106class class22{107	public function __construct(){108		echo "class22";109	}110}111class class23{112	public function __construct(){113		echo "class23";114	}115}116class class24{117	public function __construct(){118		echo "class24";119	}120}121class class25{122	public function __construct(){123		echo "class25";124	}125}126class class26{127	public function __construct(){128		echo "class26";129	}130}131class class27{132	public function __construct(){133		echo "class27";134	}135}136class class28{137	public function __construct(){

1class Test{2    public function __construct(){3        $this->method1();4    }5    public function method1(){6        $this->method2();7    }8    public function method2(){9        $this->method3();10    }11    public function method3(){12        $this->method4();13    }14    public function method4(){15        echo "method4";16    }17}18$test = new Test();19class Test{20    public function __construct(){21        $this->method1();22    }23    public function method1(){24        $this->method2();25    }26    public function method2(){27        $this->method3();28    }29    public function method3(){30        $this->method4();31    }32    public function method4(){33        $this->method5();34    }35    public function method5(){36        echo "method5";37    }38}39$test = new Test();40class Test{41    public function __construct(){42        $this->method1();43    }44    public function method1(){45        $this->method2();46    }47    public function method2(){48        $this->method3();49    }50    public function method3(){51        $this->method4();52    }53    public function method4(){54        $this->method5();55    }56    public function method5(){57        $this->method6();58    }59    public function method6(){60        echo "method6";61    }62}63$test = new Test();64class Test{65    public function __construct(){66        $this->method1();67    }68    public function method1(){69        $this->method2();70    }71    public function method2(){72        $this->method3();73    }74    public function method3(){75        $this->method4();76    }77    public function method4(){78        $this->method5();79    }80    public function method5(){81        $this->method6();82    }83    public function method6(){84        $this->method7();85    }86    public function method7(){87        echo "method7";88    }89}90$test = new Test();

1$var = new MyClass();2$var->myFunction();3$var = new MyClass();4$var->myFunction();5$var = new MyClass();6$var->myFunction();7$var = new MyClass();8$var->myFunction();9$var = new MyClass();10$var->myFunction();11$var = new MyClass();12$var->myFunction();13$var = new MyClass();14$var->myFunction();15$var = new MyClass();16$var->myFunction();17$var = new MyClass();18$var->myFunction();19$var = new MyClass();20$var->myFunction();21$var = new MyClass();22$var->myFunction();23$var = new MyClass();24$var->myFunction();25$var = new MyClass();26$var->myFunction();27$var = new MyClass();28$var->myFunction();29$var = new MyClass();30$var->myFunction();31$var = new MyClass();32$var->myFunction();33$var = new MyClass();34$var->myFunction();

1include('class.php');2$object = new class();3$object->method1();4$object->method2();5include('class.php');6$object = new class();7$object->method1();8$object->method2();9include('class.php');10$object = new class();11$object->method1();12$object->method2();13{14    function method1()15    {16    }17    function method2()18    {19    }20}21include('class.php');22$object = new class();23$object->method1();24$object->method2();25include('class.php');26$object = new class();27$object->method1();28$object->method2();29include('class.php');30$object = new class();31$object->method1();32$object->method2();33{34    function method1()35    {36    }37    function method2()38    {39    }40}41include('class.php');42$object = new class();43$object->method1();44$object->method2();45include('class.php');46$object = new class();47$object->method1();48$object->method2();49include('class.php');50$object = new class();51$object->method1();52$object->method2();