移动设备适合性测试工具-Search Console（移动测试工具有哪些）

25-02-05 16

最近很多小伙伴都在问移动设备适合性测试工具-SearchConsole和移动测试工具有哪些这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展Adsense毁了移动设备的Pagespe

最近很多小伙伴都在问移动设备适合性测试工具-Search Console和移动测试工具有哪些这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展Adsense 毁了移动设备的 Pagespeed 得分，移动设备 50，桌面设备 98、cocos2d-x 资源搜索路径 addSearchPath addSearchResolutionsOrder、Collections.binarySearch、com.intellij.psi.search.searches.DefinitionsScopedSearch的实例源码等相关知识，下面开始了哦！

本文目录一览：

移动设备适合性测试工具-Search Console（移动测试工具有哪些）
Adsense 毁了移动设备的 Pagespeed 得分，移动设备 50，桌面设备 98
cocos2d-x 资源搜索路径 addSearchPath addSearchResolutionsOrder
Collections.binarySearch
com.intellij.psi.search.searches.DefinitionsScopedSearch的实例源码

移动设备适合性测试工具-Search Console（移动测试工具有哪些）

依靠 Search Console 的移动设备合适性检测工具，您能够轻轻松松迅速地检测自身网站上的网页页面是不是合适移动设备。Search Console 会友情提示留意网站出现严重问题（比如检验到网站被黑內容），并可以协助您管理方法您的內容发生在搜索結果中的实际效果。

Search Console详细介绍：

SearchConsole中的专用工具与汇报可协助您考量您网站的搜索总流量和搜索排行状况、处理有关难题及其让您的网站在Google搜索結果中出类拔萃。

1.依靠“搜索剖析”汇报，提升您网站的內容

掌握什么查看会吸引住客户浏览您的网站。剖析您的网站在Google搜索中得到的展现频次、点一下频次和排行。

2.使您的內容纳入Google索引中

递交站点和每个网址，以供爬取。您可查询自身的索引覆盖面积，保证Google已百度收录您网站的全新主视图。

3.接受难题提示并处理网站难题

接受当Google检验到您网站上存在的问题时向您推送的电子邮箱提示。您可在电子邮件中查询什么网址遭受了这种难题的危害，并在处理这种难题后告之Google。

4.掌握Google搜索怎么查看您的网页页面

这款网址查验专用工具会立即从Google索引中查找出相关您网页页面的爬取、索引和展现状况的信息内容。

5、Search Console移动设备合适性测试工具网址

Search Console移动设备合适性测试工具网址：https://search.google.com/test/mobile-friendly?utm_source=mft&utm_medium=redirect&utm_campaign=mft-redirect

Adsense 毁了移动设备的 Pagespeed 得分，移动设备 50，桌面设备 98

Adsense 是加载第三方代码的第三方网络，您无法控制他们的资源。 Adsense 广告脚本、图像和 css 文件优化不佳。您可以做的是考虑延迟加载广告。或者接受它。

cocos2d-x 资源搜索路径 addSearchPath addSearchResolutionsOrder

转自:http://blog.csdn.net/ruanyubiao/article/details/25890997

今天遇到了资源找不到的问题，看了代码，了解了下cocos2d的资源搜索方式

新建一个项目，我的路径F:/projects/luatest/

CCFileUtils::getInstance()->addSearchPath("F:/projects/luatest2");  
CCFileUtils::getInstance()->addSearchPath("src");  
/* 
此时 
searchPath 有3个 
1. "F:/projects/luatest/"  默认项目路径 
2. "F:/projects/luatest2" 
3. "F:/projects/luatest/src/" 
 
*/  
CCFileUtils::getInstance()->addSearchResolutionsOrder("res");  
  
/* 
resourceDirectory 有2个 
1. ""    默认，空 
2. "res/" 
*/  
  
//测试：寻找close.png，这个文件不存在，看看cocos2d搜索了哪些路径CCFileUtils::getInstance()->fullPathForFilename("Images/close.png");  
/* 
cocos2d搜索的时候，会把文件名分拆成两部分，具体看CCFileUtils.cpp的FileUtils::getPathForFilename 
file_path = "Images/" 
filename ="close.png" 
*/  
  
/* 
//搜索路径组合方式： searchPath + file_path + resourceDirectory + filename 
 
最终搜索的所有路径 
F:/projects/luatest/Images/close.png 
F:/projects/luatest/Images/res/close.png 
F:/projects/luatest2/Images/close.png 
F:/projects/luatest2/Images/res/close.png 
F:/projects/luatest/src/Images/close.png 
F:/projects/luatest/src/Images/res/close.png 
*/

Collections.binarySearch

首先，RandomAccess接口用来标记一个List是支持高性能随机访问的，而BINARYSEARCH_THRESHOLD是Collections的一个常量（5000），它是二分查找的阀值。
binarySearch提供一个二分法查找的方法，参数是List和一个需要查找的key：
public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
当一个List支持高性能随机访问，或者大小小于二分查找阀值的时候，按下标二分查找；否则，用迭代器实现二分查找：
if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
return Collections.indexedBinarySearch(list, key);
else
return Collections.iteratorBinarySearch(list, key);

------------------------------------------------------------------------------------------
indexedBinarySearch方法在比较的时候会按照下标来获取列表中的元素：
Comparable<? super T> midVal = list.get(mid);
int cmp = midVal.compareTo(key);

if (cmp < 0)
low = mid + 1;
else if (cmp > 0)
high = mid - 1;
else
return mid; // key found
以上的步骤都在循环中执行，循环条件是事先定义的最小下标小于最大下标：
int low = 0;
int high = list.size()-1;

while (low <= high) {...}
每次比较前，把mid置为low和high的中间位置，如果low+high是奇数，则对(low + hight) / 2向下取整。这个过程可以用向右移位完成： int mid = (low + high) >>> 1;
最后，如果找不到，则返回一个负数：return -(low + 1);
----------------------------------------------------------------------------
iteratorBinarySearch的算法和上面完全一致，只是要用迭代器取出List中的元素
ListIterator<? extends Comparable<? super T>> i = list.listIterator();
...
Comparable<? super T> midVal = get(i, mid);
---------------------------------------------------------------------------
Collections还提供了另外两个多态方法，在上述两个二分查找方法中增加一个参数Comparator，在比较元素的时候使用这个特定的比较器，其他实现完全一致。因此，也就提供了另一个binarySearch的公共方法，在原先的方法里加上比较器参数：
public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) {
if (c==null)
return binarySearch((List) list, key);

if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
return Collections.indexedBinarySearch(list, key, c);
else
return Collections.iteratorBinarySearch(list, key, c);
}

com.intellij.psi.search.searches.DefinitionsScopedSearch的实例源码

项目：intellij-ce-playground 文件：ImplementationSearcher.java

@Nullable("For the case the search has been cancelled")
protected PsiElement[] searchDeFinitions(final PsiElement element,final Editor editor) {
  final PsiElement[][] result = new PsiElement[1][];
  if (!ProgressManager.getInstance().runProcessWithProgressSynchronously(new Runnable() {
    @Override
    public void run() {
      try {
        result[0] = DeFinitionsScopedSearch.search(element,getSearchScope(element,editor)).toArray(PsiElement.EMPTY_ARRAY);
      }
      catch (IndexNotReadyException e) {
        dumbModeNotification(element);
        result[0] = null;
      }
    }
  },SEARCHING_FOR_IMPLEMENTATIONS,true,element.getProject())) {
    return null;
  }
  return result[0];
}

项目：consulo-csharp 文件：CSharpTypeImplementationSearcher.java

@Override
public boolean execute(@NotNull DeFinitionsScopedSearch.SearchParameters queryParameters,@NotNull final Processor<PsiElement> consumer)
{
    final PsiElement element = queryParameters.getElement();
    if(element instanceof DotNetTypeDeclaration)
    {
        return TypeInheritoRSSearch.search((DotNetTypeDeclaration) element,queryParameters.getScope(),queryParameters.isCheckDeep(),CSharpTransform.INSTANCE).forEach(new Processor<DotNetTypeDeclaration>()

        {
            @Override
            public boolean process(DotNetTypeDeclaration typeDeclaration)
            {
                return consumer.process(typeDeclaration);
            }
        });
    }
    return true;
}

项目：consulo-haxe 文件：HaxeInheritanceDeFinitionsSearchExecutor.java

public static List<HaxeClass> getItemsByQName(final HaxeClass haxeClass)
{
    final List<HaxeClass> result = new ArrayList<HaxeClass>();
    DeFinitionsScopedSearch.search(haxeClass).forEach(new Processor<PsiElement>()
    {
        @Override
        public boolean process(PsiElement element)
        {
            if(element instanceof HaxeClass)
            {
                result.add((HaxeClass) element);
            }
            return true;
        }
    });
    return result;
}

项目：intellij-ce-playground 文件：MethodImplementationsSearch.java

@Override
public boolean execute(@NotNull final DeFinitionsScopedSearch.SearchParameters queryParameters,@NotNull final Processor<PsiElement> consumer) {
  final PsiElement sourceElement = queryParameters.getElement();
  if (sourceElement instanceof PsiMethod) {
    return processImplementations((PsiMethod)sourceElement,consumer,queryParameters.getScope());
  }
  return true;
}

项目：intellij-ce-playground 文件：GotoImplementationAction.java

@Override
public void update(final AnActionEvent event) {
  if (!DeFinitionsScopedSearch.INSTANCE.hasAnyExecutors()) {
    event.getPresentation().setVisible(false);
  }
  else {
    super.update(event);
  }
}

项目：intellij-ce-playground 文件：GroovyImplementationSearch.java

@Override
public boolean execute(@NotNull final DeFinitionsScopedSearch.SearchParameters queryParameters,@NotNull final Processor<PsiElement> consumer) {
  return ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
    @Override
    public Boolean compute() {
      final PsiElement source = queryParameters.getElement();
      if (!source.isValid()) return true;

      if (source instanceof GrAccessorMethod) {
        GrField property = ((GrAccessorMethod)source).getproperty();
        return consumer.process(property);
      }
      else {
        final SearchScope searchScope = queryParameters.getScope();
        if (source instanceof GrMethod) {
          GrReflectedMethod[] reflectedMethods = ((GrMethod)source).getReflectedMethods();
          for (GrReflectedMethod reflectedMethod : reflectedMethods) {
            if (!MethodImplementationsSearch.processImplementations(reflectedMethod,searchScope)) return false;
          }
        }

        else if (source instanceof GrField) {
          for (GrAccessorMethod method : GroovyPropertyUtils.getFieldAccessors((GrField)source)) {
            if (!MethodImplementationsSearch.processImplementations(method,searchScope)) return false;
          }
        }
      }
      return true;
    }
  });
}

项目：consulo-csharp 文件：CSharpMethodImplementationsSearcher.java

@Override
public boolean execute(@NotNull DeFinitionsScopedSearch.SearchParameters queryParameters,@NotNull Processor<PsiElement> consumer)
{
    PsiElement element = queryParameters.getElement();
    if(element instanceof DotNetVirtualImplementOwner)
    {
        Collection<DotNetVirtualImplementOwner> members = ReadAction.compute(() -> OverrideUtil.collectOverridenMembers((DotNetVirtualImplementOwner) element));
        return ContainerUtil.process(members,consumer);
    }
    return true;
}

项目：consulo 文件：GotoImplementationAction.java

@requireddispatchThread
@Override
public void update(final AnActionEvent event) {
  if (!DeFinitionsScopedSearch.INSTANCE.hasAnyExecutors()) {
    event.getPresentation().setVisible(false);
  }
  else {
    super.update(event);
  }
}

项目：consulo 文件：PomDeFinitionSearch.java

@Override
public boolean execute(@Nonnull DeFinitionsScopedSearch.SearchParameters parameters,@Nonnull Processor<PsiElement> consumer) {
  PsiElement element = parameters.getElement();
  if (element instanceof PomTargetPsiElement) {
    final PomTarget target = ((PomTargetPsiElement)element).getTarget();
    if (target instanceof PsiTarget) {
      if (!consumer.process(((PsiTarget)target).getNavigationElement())) return false;
    }
  }
  return true;
}

项目：consulo-javascript 文件：JSParameterInfoHandler.java

@Override
public Object[] getParametersForLookup(final LookupElement item,final ParameterInfoContext context)
{
    if(!(item instanceof MutableLookupElement))
    {
        return null;
    }

    PsiElement element = item.getPsiElement();
    if(element instanceof JSFunction)
    {
        final JSFunction originalFunction = (JSFunction) element;
        final List<JSFunction> lookupItems = new ArrayList<JSFunction>();
        Set<String> availableSignatures = new HashSet<String>();

        for(PsiElement el : DeFinitionsScopedSearch.search(originalFunction))
        {
            doAddSignature(lookupItems,availableSignatures,el);
        }

        if(lookupItems.size() == 0)
        {
            lookupItems.add(originalFunction);
        }

        return lookupItems.toArray(new Object[lookupItems.size()]);
    }

    return ArrayUtil.EMPTY_OBJECT_ARRAY;
}

项目：consulo-java 文件：MethodImplementationsSearch.java

@Override
public boolean execute(@NotNull final DeFinitionsScopedSearch.SearchParameters queryParameters,@NotNull final Processor<PsiElement> consumer)
{
    final PsiElement sourceElement = queryParameters.getElement();
    if(sourceElement instanceof PsiMethod)
    {
        return processImplementations((PsiMethod) sourceElement,queryParameters.getScope());
    }
    return true;
}

项目：intellij-ce-playground 文件：ClassImplementationsSearch.java

@Override
public boolean execute(@NotNull DeFinitionsScopedSearch.SearchParameters queryParameters,@NotNull Processor<PsiElement> consumer) {
  final PsiElement sourceElement = queryParameters.getElement();
  return !(sourceElement instanceof PsiClass) || processImplementations((PsiClass)sourceElement,queryParameters.getScope());
}

项目：consulo-haxe 文件：HaxeInheritanceDeFinitionsSearchExecutor.java

@Override
public boolean execute(@NotNull final DeFinitionsScopedSearch.SearchParameters parameters,@NotNull final Processor<PsiElement> consumer)
{
    final PsiElement queryParameters = parameters.getElement();
    return ApplicationManager.getApplication().runReadAction(new Computable<Boolean>()
    {
        public Boolean compute()
        {
            final PsiElement queryParametersParent = queryParameters.getParent();
            HaxeNamedComponent haxeNamedComponent;
            if(queryParameters instanceof HaxeClass)
            {
                haxeNamedComponent = (HaxeClass) queryParameters;
            }
            else if(queryParametersParent instanceof HaxeNamedComponent && queryParameters instanceof HaxeComponentName)
            {
                haxeNamedComponent = (HaxeNamedComponent) queryParametersParent;
            }
            else
            {
                return true;
            }
            if(haxeNamedComponent instanceof HaxeClass)
            {
                processInheritors(((HaxeClass) haxeNamedComponent).getQualifiedname(),queryParameters,consumer);
            }
            else if(HaxeComponentType.typeOf(haxeNamedComponent) == HaxeComponentType.METHOD || HaxeComponentType.typeOf(haxeNamedComponent) == HaxeComponentType.FIELD)
            {
                final String nametoFind = haxeNamedComponent.getName();
                if(nametoFind == null)
                {
                    return true;
                }

                HaxeClass haxeClass = PsiTreeUtil.getParentOfType(haxeNamedComponent,HaxeClass.class);
                assert haxeClass != null;

                processInheritors(haxeClass.getQualifiedname(),new Processor<PsiElement>()
                {
                    @Override
                    public boolean process(PsiElement element)
                    {
                        for(HaxeNamedComponent subHaxeNamedComponent : HaxeResolveUtil.getNamedSubComponents((HaxeClass) element))
                        {
                            if(nametoFind.equals(subHaxeNamedComponent.getName()))
                            {
                                consumer.process(subHaxeNamedComponent);
                            }
                        }
                        return true;
                    }
                });
            }
            return true;
        }
    });
}

项目：consulo 文件：ImplementationSearcher.java

protected Query<PsiElement> search(PsiElement element,Editor editor) {
  return DeFinitionsScopedSearch.search(element,editor),isSearchDeep());
}

项目：consulo-java 文件：ClassImplementationsSearch.java

@Override
public boolean execute(@NotNull DeFinitionsScopedSearch.SearchParameters queryParameters,@NotNull Processor<PsiElement> consumer)
{
    final PsiElement sourceElement = queryParameters.getElement();
    return !(sourceElement instanceof PsiClass) || processImplementations((PsiClass) sourceElement,queryParameters.getScope());
}

我们今天的关于移动设备适合性测试工具-Search Console和移动测试工具有哪些的分享已经告一段落，感谢您的关注，如果您想了解更多关于Adsense 毁了移动设备的 Pagespeed 得分，移动设备 50，桌面设备 98、cocos2d-x 资源搜索路径 addSearchPath addSearchResolutionsOrder、Collections.binarySearch、com.intellij.psi.search.searches.DefinitionsScopedSearch的实例源码的相关信息，请在本站查询。

本文标签：